From 709c0d84f37f1ae8f7327a83b9613e1cc26afa15 Mon Sep 17 00:00:00 2001 From: Safia Abdalla Date: Wed, 29 Mar 2023 14:34:00 -0700 Subject: [PATCH] Update RDG to use interceptors feature --- Directory.Build.props | 1 + eng/Versions.props | 20 +- .../Http.Extensions/gen/GeneratorSteps.cs | 5 +- .../gen/RequestDelegateGenerator.cs | 224 +- .../gen/RequestDelegateGeneratorSources.cs | 98 +- .../Emitters/EmitterConstants.cs | 3 +- .../Emitters/EmitterContext.cs | 3 +- .../Emitters/EmitterExtensions.cs | 3 +- .../Emitters/EndpointEmitter.cs | 217 ++ .../Emitters/EndpointParameterEmitter.cs | 288 +- .../Emitters/EndpointResponseEmitter.cs | 92 + .../Model/ConstructorParameter.cs | 2 +- .../Model}/Endpoint.cs | 13 +- .../Model}/EndpointDelegateComparer.cs | 2 +- .../Model}/EndpointParameter.cs | 6 +- .../Model}/EndpointParameterSource.cs | 2 +- .../Model}/EndpointResponse.cs | 4 +- .../Model}/InvocationOperationExtensions.cs | 2 +- .../Model/ParameterLookupKey.cs | 2 +- .../Emitters/EndpointEmitter.cs | 129 - .../Emitters/EndpointJsonResponseEmitter.cs | 28 - .../StaticRouteHandlerModel.Emitter.cs | 401 --- ...MapAction_BindAsync_Snapshot.generated.txt | 2943 ++++++++--------- ...Param_ComplexReturn_Snapshot.generated.txt | 330 +- ...Header_ComplexTypeArrayParam.generated.txt | 218 +- ...der_NullableStringArrayParam.generated.txt | 186 +- ...licitHeader_StringArrayParam.generated.txt | 186 +- ...tQuery_ComplexTypeArrayParam.generated.txt | 218 +- ...ery_NullableStringArrayParam.generated.txt | 184 +- ...plicitQuery_StringArrayParam.generated.txt | 184 +- ...eParam_SimpleReturn_Snapshot.generated.txt | 462 ++- ...Source_SimpleReturn_Snapshot.generated.txt | 810 ++--- ...tQuery_ComplexTypeArrayParam.generated.txt | 220 +- ...ery_NullableStringArrayParam.generated.txt | 184 +- ...gArrayParam_EmptyQueryValues.generated.txt | 184 +- ...ngArrayParam_QueryNotPresent.generated.txt | 184 +- ...plicitQuery_StringArrayParam.generated.txt | 184 +- ...ce_HandlesBothJsonAndService.generated.txt | 246 +- ...pecialTypeParam_StringReturn.generated.txt | 170 +- ...ipleStringParam_StringReturn.generated.txt | 234 +- ...aram_StringReturn_WithFilter.generated.txt | 158 +- ...n_ReturnsString_Has_Metadata.generated.txt | 158 +- ...ion_ReturnsTodo_Has_Metadata.generated.txt | 164 +- ...onProblemResult_Has_Metadata.generated.txt | 156 +- ..._ReturnsVoid_Has_No_Metadata.generated.txt | 152 +- ...omplexTypeParam_StringReturn.generated.txt | 218 +- ...SingleEnumParam_StringReturn.generated.txt | 218 +- ...ngValueProvided_StringReturn.generated.txt | 182 +- ...MetadataEmitter_Has_Metadata.generated.txt | 216 +- ...String_AndBody_ShouldUseBody.generated.txt | 214 +- ...hArrayQueryString_ShouldFail.generated.txt | 218 +- ...pAction_NoParam_StringReturn.generated.txt | 514 +-- ...tion_WithParams_StringReturn.generated.txt | 428 ++- ...ateValidateGeneratedFormCode.generated.txt | 346 +- .../VerifyAsParametersBaseline.generated.txt | 948 +++--- .../CompileTimeCreationTests.cs | 25 + .../RequestDelegateCreationTestBase.cs | 27 +- .../RequestDelegateCreationTests.Arrays.cs | 2 +- .../RequestDelegateCreationTests.BindAsync.cs | 2 +- .../RequestDelegateCreationTests.Metadata.cs | 2 +- ...stDelegateCreationTests.QueryParameters.cs | 2 +- .../RequestDelegateCreationTests.TryParse.cs | 3 +- .../RequestDelegateCreationTests.cs | 12 +- src/Shared/RoslynUtils/CodeWriter.cs | 6 + 64 files changed, 6654 insertions(+), 6589 deletions(-) rename src/Http/Http.Extensions/gen/{StaticRouteHandlerModel => StaticRouteHandler}/Emitters/EmitterConstants.cs (97%) rename src/Http/Http.Extensions/gen/{StaticRouteHandlerModel => StaticRouteHandler}/Emitters/EmitterContext.cs (96%) rename src/Http/Http.Extensions/gen/{StaticRouteHandlerModel => StaticRouteHandler}/Emitters/EmitterExtensions.cs (95%) create mode 100644 src/Http/Http.Extensions/gen/StaticRouteHandler/Emitters/EndpointEmitter.cs rename src/Http/Http.Extensions/gen/{StaticRouteHandlerModel => StaticRouteHandler}/Emitters/EndpointParameterEmitter.cs (57%) create mode 100644 src/Http/Http.Extensions/gen/StaticRouteHandler/Emitters/EndpointResponseEmitter.cs rename src/Http/Http.Extensions/gen/{StaticRouteHandlerModel => StaticRouteHandler}/Model/ConstructorParameter.cs (93%) rename src/Http/Http.Extensions/gen/{StaticRouteHandlerModel => StaticRouteHandler/Model}/Endpoint.cs (91%) rename src/Http/Http.Extensions/gen/{StaticRouteHandlerModel => StaticRouteHandler/Model}/EndpointDelegateComparer.cs (96%) rename src/Http/Http.Extensions/gen/{StaticRouteHandlerModel => StaticRouteHandler/Model}/EndpointParameter.cs (99%) rename src/Http/Http.Extensions/gen/{StaticRouteHandlerModel => StaticRouteHandler/Model}/EndpointParameterSource.cs (97%) rename src/Http/Http.Extensions/gen/{StaticRouteHandlerModel => StaticRouteHandler/Model}/EndpointResponse.cs (99%) rename src/Http/Http.Extensions/gen/{StaticRouteHandlerModel => StaticRouteHandler/Model}/InvocationOperationExtensions.cs (99%) rename src/Http/Http.Extensions/gen/{StaticRouteHandlerModel => StaticRouteHandler}/Model/ParameterLookupKey.cs (97%) delete mode 100644 src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Emitters/EndpointEmitter.cs delete mode 100644 src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Emitters/EndpointJsonResponseEmitter.cs delete mode 100644 src/Http/Http.Extensions/gen/StaticRouteHandlerModel/StaticRouteHandlerModel.Emitter.cs diff --git a/Directory.Build.props b/Directory.Build.props index e5a2b95bfab1..c2bc06baaa24 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -13,6 +13,7 @@ true latest Default + /Users/captainsafia/repos/roslyn/artifacts/packages/Release/Shipping diff --git a/eng/Versions.props b/eng/Versions.props index f17d48c5d302..1c815b01b82d 100644 --- a/eng/Versions.props +++ b/eng/Versions.props @@ -136,10 +136,10 @@ 8.0.0-preview.5.23268.2 8.0.0-preview.5.23268.2 - 4.4.0-4.22520.2 - 4.4.0-4.22520.2 - 4.4.0-4.22520.2 - 4.4.0-4.22520.2 + 4.7.0-dev + 4.7.0-dev + 4.7.0-dev + 4.7.0-dev 6.2.2 @@ -231,11 +231,13 @@ 3.3.1 - 4.5.0 - 4.4.0-4.22520.2 - 4.4.0-4.22520.2 - 4.4.0-4.22520.2 - 4.4.0-4.22520.2 + 4.7.0-dev + 4.7.0-dev + 4.7.0-dev + 4.7.0-dev + 4.7.0-dev + true + 4.7.0-dev 3.3.3 1.1.2-beta1.22531.1 1.1.2-beta1.22531.1 diff --git a/src/Http/Http.Extensions/gen/GeneratorSteps.cs b/src/Http/Http.Extensions/gen/GeneratorSteps.cs index 2608f97a1ee6..a90776d30178 100644 --- a/src/Http/Http.Extensions/gen/GeneratorSteps.cs +++ b/src/Http/Http.Extensions/gen/GeneratorSteps.cs @@ -5,5 +5,8 @@ namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator; internal class GeneratorSteps { internal const string EndpointModelStep = nameof(EndpointModelStep); - internal const string EndpointsWithoutDiagnosicsStep = nameof(EndpointsWithoutDiagnosicsStep); + internal const string EndpointsWithoutDiagnosticsStep = nameof(EndpointsWithoutDiagnosticsStep); + internal const string EndpointsInterceptorsStep = nameof(EndpointsInterceptorsStep); + internal const string EndpointsHelperMethodsStep = nameof(EndpointsHelperMethodsStep); + internal const string EndpointsHelperTypesStep = nameof(EndpointsHelperTypesStep); } diff --git a/src/Http/Http.Extensions/gen/RequestDelegateGenerator.cs b/src/Http/Http.Extensions/gen/RequestDelegateGenerator.cs index bfd4ba688f9c..560ea169b5cf 100644 --- a/src/Http/Http.Extensions/gen/RequestDelegateGenerator.cs +++ b/src/Http/Http.Extensions/gen/RequestDelegateGenerator.cs @@ -9,8 +9,8 @@ using Microsoft.AspNetCore.App.Analyzers.Infrastructure; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.Operations; -using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel.Emitters; -using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel; +using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Emitters; +using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Model; using Microsoft.CodeAnalysis.CSharp; namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator; @@ -53,122 +53,108 @@ public void Initialize(IncrementalGeneratorInitializationContext context) var endpoints = endpointsWithDiagnostics .Where(endpoint => endpoint.Diagnostics.Count == 0) - .WithTrackingName(GeneratorSteps.EndpointsWithoutDiagnosicsStep); - - var thunks = endpoints.Select((endpoint, _) => - { - using var stringWriter = new StringWriter(CultureInfo.InvariantCulture); - using var codeWriter = new CodeWriter(stringWriter, baseIndent: 3); - codeWriter.InitializeIndent(); - codeWriter.WriteLine($"[{endpoint.EmitSourceKey()}] = ("); - codeWriter.Indent++; - codeWriter.WriteLine("(methodInfo, options) =>"); - codeWriter.StartBlock(); - codeWriter.WriteLine(@"Debug.Assert(options != null, ""RequestDelegateFactoryOptions not found."");"); - codeWriter.WriteLine(@"Debug.Assert(options.EndpointBuilder != null, ""EndpointBuilder not found."");"); - codeWriter.WriteLine($"options.EndpointBuilder.Metadata.Add(new SourceKey{endpoint.EmitSourceKey()});"); - endpoint.EmitEndpointMetadataPopulation(codeWriter); - codeWriter.WriteLine("return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() };"); - codeWriter.EndBlockWithComma(); - codeWriter.WriteLine("(del, options, inferredMetadataResult) =>"); - codeWriter.StartBlock(); - codeWriter.WriteLine(@"Debug.Assert(options != null, ""RequestDelegateFactoryOptions not found."");"); - codeWriter.WriteLine(@"Debug.Assert(options.EndpointBuilder != null, ""EndpointBuilder not found."");"); - codeWriter.WriteLine($"var handler = ({endpoint.EmitHandlerDelegateType(considerOptionality: true)})del;"); - codeWriter.WriteLine("EndpointFilterDelegate? filteredInvocation = null;"); - if (endpoint.EmitterContext.RequiresLoggingHelper || endpoint.EmitterContext.HasJsonBodyOrService || endpoint.Response?.IsSerializableJsonResponse(out var _) is true) - { - codeWriter.WriteLine("var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices;"); - } - endpoint.EmitLoggingPreamble(codeWriter); - endpoint.EmitRouteOrQueryResolver(codeWriter); - endpoint.EmitJsonBodyOrServiceResolver(codeWriter); - endpoint.Response?.EmitJsonPreparation(codeWriter); - if (endpoint.NeedsParameterArray) - { - codeWriter.WriteLine("var parameters = del.Method.GetParameters();"); - } - codeWriter.WriteLineNoTabs(string.Empty); - codeWriter.WriteLine("if (options?.EndpointBuilder?.FilterFactories.Count > 0)"); - codeWriter.StartBlock(); - codeWriter.WriteLine(endpoint.Response?.IsAwaitable == true - ? "filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(async ic =>" - : "filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic =>"); - codeWriter.StartBlock(); - codeWriter.WriteLine("if (ic.HttpContext.Response.StatusCode == 400)"); - codeWriter.StartBlock(); - codeWriter.WriteLine("return ValueTask.FromResult(Results.Empty);"); - codeWriter.EndBlock(); - endpoint.EmitFilteredInvocation(codeWriter); - codeWriter.EndBlockWithComma(); - codeWriter.WriteLine("options.EndpointBuilder,"); - codeWriter.WriteLine("handler.Method);"); - codeWriter.EndBlock(); - codeWriter.WriteLineNoTabs(string.Empty); - endpoint.EmitRequestHandler(codeWriter); - codeWriter.WriteLineNoTabs(string.Empty); - endpoint.EmitFilteredRequestHandler(codeWriter); - codeWriter.WriteLineNoTabs(string.Empty); - codeWriter.WriteLine("RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered;"); - codeWriter.WriteLine("var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty;"); - codeWriter.WriteLine("return new RequestDelegateResult(targetDelegate, metadata);"); - codeWriter.Indent--; - codeWriter.Write("}),"); - return stringWriter.ToString(); - }); + .WithTrackingName(GeneratorSteps.EndpointsWithoutDiagnosticsStep); var stronglyTypedEndpointDefinitions = endpoints - .Collect() - .Select((endpoints, _) => + .Select((endpoint, _) => { - var dedupedByDelegate = endpoints.Distinct(EndpointDelegateComparer.Instance); using var stringWriter = new StringWriter(CultureInfo.InvariantCulture); using var codeWriter = new CodeWriter(stringWriter, baseIndent: 2); - foreach (var endpoint in dedupedByDelegate) + codeWriter.WriteLine($$"""[global::System.Runtime.CompilerServices.InterceptsLocation(@"{{endpoint!.Location.File}}", {{endpoint.Location.LineNumber}}, {{endpoint.Location.CharaceterNumber + 1}})]"""); + codeWriter.WriteLine($"internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder {endpoint!.HttpMethod}_{endpoint.Location.LineNumber}("); + codeWriter.Indent++; + codeWriter.WriteLine("this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints,"); + // MapFallback overloads that only take a delegate do not need a pattern argument + if (endpoint.HttpMethod != "MapFallback" || endpoint.Operation.Arguments.Length != 2) + { + codeWriter.WriteLine(@"[global::System.Diagnostics.CodeAnalysis.StringSyntax(""Route"")] string pattern,"); + } + // MapMethods overloads define an additional `httpMethods` parameter + if (endpoint.HttpMethod == "MapMethods") { - codeWriter.WriteLine($"internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder {endpoint.HttpMethod}("); - codeWriter.Indent++; - codeWriter.WriteLine("this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints,"); - // MapFallback overloads that only take a delegate do not need a pattern argument - if (endpoint.HttpMethod != "MapFallback" || endpoint.Operation.Arguments.Length != 2) - { - codeWriter.WriteLine(@"[global::System.Diagnostics.CodeAnalysis.StringSyntax(""Route"")] string pattern,"); - } - // MapMethods overloads define an additional `httpMethods` parameter - if (endpoint.HttpMethod == "MapMethods") - { - codeWriter.WriteLine("global::System.Collections.Generic.IEnumerable httpMethods,"); - } - codeWriter.WriteLine($"global::{endpoint.EmitHandlerDelegateType()} handler,"); - codeWriter.WriteLine(@"[global::System.Runtime.CompilerServices.CallerFilePath] string filePath = """","); - codeWriter.WriteLine("[global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0)"); - codeWriter.Indent--; - codeWriter.StartBlock(); - codeWriter.WriteLine("return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore("); - codeWriter.Indent++; - codeWriter.WriteLine("endpoints,"); - // For `MapFallback` overloads that only take a delegate, provide the assumed default - // Otherwise, pass the pattern provided from the MapX invocation - if (endpoint.HttpMethod != "MapFallback" && endpoint.Operation.Arguments.Length != 2) - { - codeWriter.WriteLine("pattern,"); - } - else - { - codeWriter.WriteLine($"{SymbolDisplay.FormatLiteral(endpoint.RoutePattern!, true)},"); - } - codeWriter.WriteLine("handler,"); - codeWriter.WriteLine($"{endpoint.EmitVerb()},"); - codeWriter.WriteLine("filePath,"); - codeWriter.WriteLine("lineNumber);"); - codeWriter.Indent--; - codeWriter.EndBlock(); + codeWriter.WriteLine("global::System.Collections.Generic.IEnumerable httpMethods,"); } + codeWriter.WriteLine($"global::System.Delegate handler)"); + codeWriter.Indent--; + codeWriter.StartBlock(); + codeWriter.WriteLine("MetadataPopulator populateMetadata = (methodInfo, options) =>"); + codeWriter.StartBlock(); + codeWriter.WriteLine(@"Debug.Assert(options != null, ""RequestDelegateFactoryOptions not found."");"); + codeWriter.WriteLine(@"Debug.Assert(options.EndpointBuilder != null, ""EndpointBuilder not found."");"); + codeWriter.WriteLine($"options.EndpointBuilder.Metadata.Add(new SourceKey{endpoint.EmitSourceKey()});"); + endpoint.EmitEndpointMetadataPopulation(codeWriter); + codeWriter.WriteLine("return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() };"); + codeWriter.EndBlockWithSemicolon(); + + codeWriter.WriteLine("RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) =>"); + codeWriter.StartBlock(); + codeWriter.WriteLine(@"Debug.Assert(options != null, ""RequestDelegateFactoryOptions not found."");"); + codeWriter.WriteLine(@"Debug.Assert(options.EndpointBuilder != null, ""EndpointBuilder not found."");"); + codeWriter.WriteLine($"var handler = Cast(del, {endpoint.EmitHandlerDelegateType(considerOptionality: true)} => throw null!);"); + codeWriter.WriteLine("EndpointFilterDelegate? filteredInvocation = null;"); + if (endpoint.EmitterContext.RequiresLoggingHelper || endpoint.EmitterContext.HasJsonBodyOrService || endpoint.Response?.IsSerializableJsonResponse(out var _) is true) + { + codeWriter.WriteLine("var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices;"); + } + endpoint.EmitLoggingPreamble(codeWriter); + endpoint.EmitRouteOrQueryResolver(codeWriter); + endpoint.EmitJsonBodyOrServiceResolver(codeWriter); + endpoint.Response?.EmitJsonPreparation(codeWriter); + if (endpoint.NeedsParameterArray) + { + codeWriter.WriteLine("var parameters = del.Method.GetParameters();"); + } + codeWriter.WriteLineNoTabs(string.Empty); + codeWriter.WriteLine("if (options?.EndpointBuilder?.FilterFactories.Count > 0)"); + codeWriter.StartBlock(); + codeWriter.WriteLine(endpoint.Response?.IsAwaitable == true + ? "filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(async ic =>" + : "filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic =>"); + codeWriter.StartBlock(); + codeWriter.WriteLine("if (ic.HttpContext.Response.StatusCode == 400)"); + codeWriter.StartBlock(); + codeWriter.WriteLine("return ValueTask.FromResult(Results.Empty);"); + codeWriter.EndBlock(); + endpoint.EmitFilteredInvocation(codeWriter); + codeWriter.EndBlockWithComma(); + codeWriter.WriteLine("options.EndpointBuilder,"); + codeWriter.WriteLine("handler.Method);"); + codeWriter.EndBlock(); + codeWriter.WriteLineNoTabs(string.Empty); + endpoint.EmitRequestHandler(codeWriter); + codeWriter.WriteLineNoTabs(string.Empty); + endpoint.EmitFilteredRequestHandler(codeWriter); + codeWriter.WriteLineNoTabs(string.Empty); + codeWriter.WriteLine("RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered;"); + codeWriter.WriteLine("var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty;"); + codeWriter.WriteLine("return new RequestDelegateResult(targetDelegate, metadata);"); + codeWriter.EndBlockWithSemicolon(); + + codeWriter.WriteLine("return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore("); + codeWriter.Indent++; + codeWriter.WriteLine("endpoints,"); + // For `MapFallback` overloads that only take a delegate, provide the assumed default + // Otherwise, pass the pattern provided from the MapX invocation + if (endpoint.HttpMethod != "MapFallback" && endpoint.Operation.Arguments.Length != 2) + { + codeWriter.WriteLine("pattern,"); + } + else + { + codeWriter.WriteLine($"{SymbolDisplay.FormatLiteral(endpoint.RoutePattern!, true)},"); + } + codeWriter.WriteLine("handler,"); + codeWriter.WriteLine($"{endpoint!.EmitVerb()},"); + codeWriter.WriteLine("populateMetadata,"); + codeWriter.WriteLine($"createRequestDelegate);"); + codeWriter.Indent--; + codeWriter.EndBlock(); return stringWriter.ToString(); - }); + }) + .WithTrackingName(GeneratorSteps.EndpointsInterceptorsStep); - var endpointHelpers = endpoints + var helperMethods = endpoints .Collect() .Select((endpoints, _) => { @@ -237,7 +223,8 @@ public void Initialize(IncrementalGeneratorInitializationContext context) } return stringWriter.ToString(); - }); + }) + .WithTrackingName(GeneratorSteps.EndpointsHelperMethodsStep); var helperTypes = endpoints .Collect() @@ -272,29 +259,28 @@ public void Initialize(IncrementalGeneratorInitializationContext context) } return stringWriter.ToString(); - }); + }) + .WithTrackingName(GeneratorSteps.EndpointsHelperTypesStep); - var thunksAndEndpoints = thunks.Collect().Combine(stronglyTypedEndpointDefinitions).Combine(endpointHelpers).Combine(helperTypes); + var thunksAndEndpoints = stronglyTypedEndpointDefinitions.Collect().Combine(helperMethods).Combine(helperTypes); context.RegisterSourceOutput(thunksAndEndpoints, (context, sources) => { - var (((thunks, endpointsCode), helperMethods), helperTypes) = sources; + var ((endpointsCode, helperMethods), helperTypes) = sources; - if (thunks.IsDefaultOrEmpty || string.IsNullOrEmpty(endpointsCode)) + if (endpointsCode.IsDefaultOrEmpty) { return; } - var thunksCode = new StringBuilder(); - foreach (var thunk in thunks) + var endpoints = new StringBuilder(); + foreach (var thunk in endpointsCode) { - thunksCode.AppendLine(thunk); + endpoints.AppendLine(thunk); } var code = RequestDelegateGeneratorSources.GetGeneratedRouteBuilderExtensionsSource( - genericThunks: string.Empty, - thunks: thunksCode.ToString(), - endpoints: endpointsCode, + endpoints: endpoints.ToString(), helperMethods: helperMethods ?? string.Empty, helperTypes: helperTypes ?? string.Empty); diff --git a/src/Http/Http.Extensions/gen/RequestDelegateGeneratorSources.cs b/src/Http/Http.Extensions/gen/RequestDelegateGeneratorSources.cs index 0caf3ddc9248..0eca2ee4d6fc 100644 --- a/src/Http/Http.Extensions/gen/RequestDelegateGeneratorSources.cs +++ b/src/Http/Http.Extensions/gen/RequestDelegateGeneratorSources.cs @@ -496,7 +496,7 @@ public override bool IsDefined(Type attributeType, bool inherit) } """; - public static string GetGeneratedRouteBuilderExtensionsSource(string genericThunks, string thunks, string endpoints, string helperMethods, string helperTypes) => $$""" + public static string GetGeneratedRouteBuilderExtensionsSource(string endpoints, string helperMethods, string helperTypes) => $$""" {{SourceHeader}} namespace Microsoft.AspNetCore.Builder @@ -513,8 +513,18 @@ public SourceKey(string path, int line) Line = line; } } +} -{{GetEndpoints(endpoints)}} +namespace System.Runtime.CompilerServices +{ + {{GeneratedCodeAttribute}} + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute + { + public InterceptsLocationAttribute(string filePath, int line, int column) + { + } + } } namespace Microsoft.AspNetCore.Http.Generated @@ -549,8 +559,29 @@ namespace Microsoft.AspNetCore.Http.Generated file static class GeneratedRouteBuilderExtensionsCore { -{{GetGenericThunks(genericThunks)}} -{{GetThunks(thunks)}} + 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; + + {{endpoints}} + + internal static RouteHandlerBuilder MapCore( + this IEndpointRouteBuilder routes, + string pattern, + Delegate handler, + IEnumerable? httpMethods, + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) + { + return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); + } + + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { @@ -595,63 +626,4 @@ private static Task ExecuteObjectResult(object? obj, HttpContext httpContext) {{LogOrThrowExceptionHelperClass}} } """; - private static string GetGenericThunks(string genericThunks) => genericThunks != string.Empty ? $$""" - private static class GenericThunks - { - public static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() - { - {{genericThunks}} - }; - } - - internal static RouteHandlerBuilder MapCore( - this IEndpointRouteBuilder routes, - string pattern, - Delegate handler, - IEnumerable httpMethods, - string filePath, - int lineNumber) - { - var (populateMetadata, createRequestDelegate) = GenericThunks.map[(filePath, lineNumber)]; - return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); - } -""" : string.Empty; - - private static string GetThunks(string thunks) => thunks != string.Empty ? $$""" - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() - { -{{thunks}} - }; - - internal static RouteHandlerBuilder MapCore( - this IEndpointRouteBuilder routes, - string pattern, - Delegate handler, - IEnumerable? httpMethods, - string filePath, - int lineNumber) - { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; - return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); - } -""" : string.Empty; - - private static string GetEndpoints(string endpoints) => endpoints != string.Empty ? $$""" - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. - {{GeneratedCodeAttribute}} - internal static class GenerateRouteBuilderEndpoints - { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - {{endpoints}} - } -""" : string.Empty; } diff --git a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Emitters/EmitterConstants.cs b/src/Http/Http.Extensions/gen/StaticRouteHandler/Emitters/EmitterConstants.cs similarity index 97% rename from src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Emitters/EmitterConstants.cs rename to src/Http/Http.Extensions/gen/StaticRouteHandler/Emitters/EmitterConstants.cs index f609f825a44a..e6ee10bad40a 100644 --- a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Emitters/EmitterConstants.cs +++ b/src/Http/Http.Extensions/gen/StaticRouteHandler/Emitters/EmitterConstants.cs @@ -1,7 +1,8 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. using Microsoft.CodeAnalysis; -namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel.Emitters; + +namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Emitters; internal static class EmitterConstants { diff --git a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Emitters/EmitterContext.cs b/src/Http/Http.Extensions/gen/StaticRouteHandler/Emitters/EmitterContext.cs similarity index 96% rename from src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Emitters/EmitterContext.cs rename to src/Http/Http.Extensions/gen/StaticRouteHandler/Emitters/EmitterContext.cs index d30a9742ef6d..f56d65fcb5c3 100644 --- a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Emitters/EmitterContext.cs +++ b/src/Http/Http.Extensions/gen/StaticRouteHandler/Emitters/EmitterContext.cs @@ -1,6 +1,7 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel.Emitters; + +namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Emitters; internal sealed class EmitterContext { diff --git a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Emitters/EmitterExtensions.cs b/src/Http/Http.Extensions/gen/StaticRouteHandler/Emitters/EmitterExtensions.cs similarity index 95% rename from src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Emitters/EmitterExtensions.cs rename to src/Http/Http.Extensions/gen/StaticRouteHandler/Emitters/EmitterExtensions.cs index b17e0614f2a6..ea21fa082555 100644 --- a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Emitters/EmitterExtensions.cs +++ b/src/Http/Http.Extensions/gen/StaticRouteHandler/Emitters/EmitterExtensions.cs @@ -3,9 +3,10 @@ using System; using System.Diagnostics.CodeAnalysis; using Microsoft.AspNetCore.Analyzers.Infrastructure; +using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Model; using Microsoft.CodeAnalysis; -namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel; +namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Emitters; internal static class EmitterExtensions { diff --git a/src/Http/Http.Extensions/gen/StaticRouteHandler/Emitters/EndpointEmitter.cs b/src/Http/Http.Extensions/gen/StaticRouteHandler/Emitters/EndpointEmitter.cs new file mode 100644 index 000000000000..6f80b5194810 --- /dev/null +++ b/src/Http/Http.Extensions/gen/StaticRouteHandler/Emitters/EndpointEmitter.cs @@ -0,0 +1,217 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using Microsoft.CodeAnalysis; +using System.Linq; +using System.Text; +using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Model; + +namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Emitters; + +internal static class EndpointEmitter +{ + public static string EmitHandlerDelegateType(this Endpoint endpoint, bool considerOptionality = false) + { + // Emits a delegate type to use when casting the input that captures + // default parameter values. + // + // void (int arg0, Todo arg1) => throw null! + // 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} ()"; + } + var parameterTypeList = string.Join(", ", endpoint.Parameters.Select((p, i) => $"{getType(p, considerOptionality)} 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})"; + + static string getType(EndpointParameter p, bool considerOptionality) + { + return considerOptionality + ? p.Type.ToDisplayString(p.IsOptional ? NullableFlowState.MaybeNull : NullableFlowState.NotNull, EmitterConstants.DisplayFormat) + : p.Type.ToDisplayString(EmitterConstants.DisplayFormat); + } + } + + public static string EmitSourceKey(this Endpoint endpoint) + { + return $@"(@""{endpoint.Location.File}"", {endpoint.Location.LineNumber})"; + } + + public static string EmitVerb(this Endpoint endpoint) + { + return endpoint.HttpMethod switch + { + "MapGet" => "GetVerb", + "MapPut" => "PutVerb", + "MapPost" => "PostVerb", + "MapDelete" => "DeleteVerb", + "MapPatch" => "PatchVerb", + "MapMethods" => "httpMethods", + "Map" => "null", + "MapFallback" => "null", + _ => throw new ArgumentException($"Received unexpected HTTP method: {endpoint.HttpMethod}") + }; + } + + /* + * Emit invocation to the request handler. The structure + * involved here consists of a call to bind parameters, check + * their validity (optionality), invoke the underlying handler with + * the arguments bound from HTTP context, and write out the response. + */ + public static void EmitRequestHandler(this Endpoint endpoint, CodeWriter codeWriter) + { + codeWriter.WriteLine(endpoint.IsAwaitable ? "async Task RequestHandler(HttpContext httpContext)" : "Task RequestHandler(HttpContext httpContext)"); + codeWriter.StartBlock(); // Start handler method block + codeWriter.WriteLine("var wasParamCheckFailure = false;"); + + if (endpoint.Parameters.Length > 0) + { + codeWriter.WriteLine(endpoint.Parameters.EmitParameterPreparation(endpoint.EmitterContext, codeWriter.Indent)); + } + + codeWriter.WriteLine("if (wasParamCheckFailure)"); + codeWriter.StartBlock(); // Start if-statement block + codeWriter.WriteLine("httpContext.Response.StatusCode = 400;"); + codeWriter.WriteLine(endpoint.IsAwaitable ? "return;" : "return Task.CompletedTask;"); + codeWriter.EndBlock(); // End if-statement block + if (endpoint.Response == null) + { + return; + } + if (!endpoint.Response.HasNoResponse && endpoint.Response is { ContentType: { } contentType }) + { + codeWriter.WriteLine($@"httpContext.Response.ContentType ??= ""{contentType}"";"); + } + if (!endpoint.Response.HasNoResponse) + { + codeWriter.Write("var result = "); + } + if (endpoint.Response.IsAwaitable) + { + codeWriter.Write("await "); + } + codeWriter.WriteLine($"handler({endpoint.EmitArgumentList()});"); + if (!endpoint.Response.HasNoResponse) + { + codeWriter.WriteLine(endpoint.Response.EmitResponseWritingCall(endpoint.IsAwaitable)); + } + else if (!endpoint.IsAwaitable) + { + codeWriter.WriteLine("return Task.CompletedTask;"); + } + codeWriter.EndBlock(); // End handler method block + } + + public static void EmitFilteredRequestHandler(this Endpoint endpoint, CodeWriter codeWriter) + { + var argumentList = endpoint.Parameters.Length == 0 ? string.Empty : $", {endpoint.EmitArgumentList()}"; + var invocationCreator = endpoint.Parameters.Length > 8 + ? "new DefaultEndpointFilterInvocationContext" + : "EndpointFilterInvocationContext.Create"; + var invocationGenericArgs = endpoint.Parameters.Length is > 0 and < 8 + ? $"<{endpoint.EmitFilterInvocationContextTypeArgs()}>" + : string.Empty; + + codeWriter.WriteLine("async Task RequestHandlerFiltered(HttpContext httpContext)"); + codeWriter.StartBlock(); // Start handler method block + codeWriter.WriteLine("var wasParamCheckFailure = false;"); + + if (endpoint.Parameters.Length > 0) + { + codeWriter.WriteLine(endpoint.Parameters.EmitParameterPreparation(endpoint.EmitterContext, codeWriter.Indent)); + } + + codeWriter.WriteLine("if (wasParamCheckFailure)"); + codeWriter.StartBlock(); // Start if-statement block + codeWriter.WriteLine("httpContext.Response.StatusCode = 400;"); + codeWriter.EndBlock(); // End if-statement block + codeWriter.WriteLine($"var result = await filteredInvocation({invocationCreator}{invocationGenericArgs}(httpContext{argumentList}));"); + codeWriter.WriteLine("await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext);"); + codeWriter.EndBlock(); // End handler method block + } + + public static void EmitEndpointMetadataPopulation(this Endpoint endpoint, CodeWriter codeWriter) + { + endpoint.EmitAcceptsMetadata(codeWriter); + endpoint.EmitBuiltinResponseTypeMetadata(codeWriter); + endpoint.EmitCallsToMetadataProvidersForParameters(codeWriter); + endpoint.EmitCallToMetadataProviderForResponse(codeWriter); + } + + public static void EmitFilteredInvocation(this Endpoint endpoint, CodeWriter codeWriter) + { + if (endpoint.Response?.HasNoResponse == true) + { + codeWriter.WriteLine(endpoint.Response?.IsAwaitable == true + ? $"await handler({endpoint.EmitFilteredArgumentList()});" + : $"handler({endpoint.EmitFilteredArgumentList()});"); + codeWriter.WriteLine("return ValueTask.FromResult(Results.Empty);"); + } + else if (endpoint.Response?.IsAwaitable == true) + { + codeWriter.WriteLine($"var result = await handler({endpoint.EmitFilteredArgumentList()});"); + codeWriter.WriteLine("return (object?)result;"); + } + else + { + codeWriter.WriteLine($"return ValueTask.FromResult(handler({endpoint.EmitFilteredArgumentList()}));"); + } + } + + private static string EmitFilteredArgumentList(this Endpoint endpoint) + { + if (endpoint.Parameters.Length == 0) + { + return string.Empty; + } + + var sb = new StringBuilder(); + + for (var i = 0; i < endpoint.Parameters.Length; i++) + { + // The null suppression operator on the GetArgument(...) call here is required because we'll occassionally be + // dealing with nullable types here. We could try to do fancy things to branch the logic here depending on + // the nullability, but at the end of the day we are going to call GetArguments(...) - at runtime the nullability + // suppression operator doesn't come into play - so its not worth worrying about. + sb.Append($"ic.GetArgument<{endpoint.Parameters[i].Type.ToDisplayString(EmitterConstants.DisplayFormat)}>({i})!"); + + if (i < endpoint.Parameters.Length - 1) + { + sb.Append(", "); + } + } + + return sb.ToString(); + } + + private static string EmitFilterInvocationContextTypeArgs(this Endpoint endpoint) + { + if (endpoint.Parameters.Length == 0) + { + return string.Empty; + } + + var sb = new StringBuilder(); + + for (var i = 0; i < endpoint.Parameters.Length; i++) + { + sb.Append(endpoint.Parameters[i].Type.ToDisplayString(endpoint.Parameters[i].IsOptional ? NullableFlowState.MaybeNull : NullableFlowState.NotNull, EmitterConstants.DisplayFormat)); + + if (i < endpoint.Parameters.Length - 1) + { + sb.Append(", "); + } + } + + return sb.ToString(); + } + + private static string EmitArgumentList(this Endpoint endpoint) => string.Join(", ", endpoint.Parameters.Select(p => p.EmitArgument())); +} diff --git a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Emitters/EndpointParameterEmitter.cs b/src/Http/Http.Extensions/gen/StaticRouteHandler/Emitters/EndpointParameterEmitter.cs similarity index 57% rename from src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Emitters/EndpointParameterEmitter.cs rename to src/Http/Http.Extensions/gen/StaticRouteHandler/Emitters/EndpointParameterEmitter.cs index 0b5aed0f2308..c33c374ea222 100644 --- a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Emitters/EndpointParameterEmitter.cs +++ b/src/Http/Http.Extensions/gen/StaticRouteHandler/Emitters/EndpointParameterEmitter.cs @@ -2,19 +2,144 @@ // The .NET Foundation licenses this file to you under the MIT license. using System; +using System.Collections.Generic; +using System.Globalization; +using System.IO; +using System.Linq; using Microsoft.AspNetCore.Analyzers.Infrastructure; using Microsoft.AspNetCore.Analyzers.RouteEmbeddedLanguage.Infrastructure; +using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Model; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; -namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel.Emitters; +namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Emitters; internal static class EndpointParameterEmitter { - internal static void EmitSpecialParameterPreparation(this EndpointParameter endpointParameter, CodeWriter codeWriter) + /* + * Iterates through all of the provided parameters + * in a given endpoint and invokes the appropriate + * emission sub-function based on the parameter type. + */ + public static string EmitParameterPreparation(this IEnumerable endpointParameters, EmitterContext emitterContext, int baseIndent = 0) + { + using var stringWriter = new StringWriter(CultureInfo.InvariantCulture); + using var parameterPreparationBuilder = new CodeWriter(stringWriter, baseIndent); + var readFormEmitted = false; + + foreach (var parameter in endpointParameters) + { + switch (parameter.Source) + { + case EndpointParameterSource.SpecialType: + parameter.EmitSpecialParameterPreparation(parameterPreparationBuilder); + break; + case EndpointParameterSource.Query: + case EndpointParameterSource.Header: + parameter.EmitQueryOrHeaderParameterPreparation(parameterPreparationBuilder); + break; + case EndpointParameterSource.Route: + parameter.EmitRouteParameterPreparation(parameterPreparationBuilder); + break; + case EndpointParameterSource.RouteOrQuery: + emitterContext.HasRouteOrQuery = true; + parameter.EmitRouteOrQueryParameterPreparation(parameterPreparationBuilder); + break; + case EndpointParameterSource.BindAsync: + emitterContext.HasBindAsync = true; + parameter.EmitBindAsyncPreparation(parameterPreparationBuilder); + break; + case EndpointParameterSource.JsonBody: + parameter.EmitJsonBodyParameterPreparationString(parameterPreparationBuilder); + break; + case EndpointParameterSource.FormBody: + parameter.EmitFormParameterPreparation(parameterPreparationBuilder, ref readFormEmitted); + break; + case EndpointParameterSource.JsonBodyOrService: + parameter.EmitJsonBodyOrServiceParameterPreparationString(parameterPreparationBuilder); + break; + case EndpointParameterSource.Service: + parameter.EmitServiceParameterPreparation(parameterPreparationBuilder); + break; + case EndpointParameterSource.AsParameters: + parameter.EmitAsParametersParameterPreparation(parameterPreparationBuilder, emitterContext); + break; + } + } + + return stringWriter.ToString(); + } + + /* + * Emits resolvers that are invoked once at startup + * for initializing how parameters that are ambiguous + * at compile-time should be resolved. + */ + public static void EmitRouteOrQueryResolver(this Endpoint endpoint, CodeWriter codeWriter) + { + foreach (var parameter in endpoint.Parameters) + { + ProcessParameter(parameter, codeWriter, endpoint); + if (parameter is { Source: EndpointParameterSource.AsParameters, EndpointParameters: {} innerParameters }) + { + foreach (var innerParameter in innerParameters) + { + ProcessParameter(innerParameter, codeWriter, endpoint); + } + } + } + + static void ProcessParameter(EndpointParameter parameter, CodeWriter codeWriter, Endpoint endpoint) + { + if (parameter.Source == EndpointParameterSource.RouteOrQuery) + { + var parameterName = parameter.SymbolName; + codeWriter.Write($@"var {parameterName}_RouteOrQueryResolver = "); + codeWriter.WriteLine($@"GeneratedRouteBuilderExtensionsCore.ResolveFromRouteOrQuery(""{parameterName}"", options?.RouteParameterNames);"); + endpoint.EmitterContext.HasRouteOrQuery = true; + } + } + } + + public static void EmitJsonBodyOrServiceResolver(this Endpoint endpoint, CodeWriter codeWriter) + { + var serviceProviderEmitted = false; + foreach (var parameter in endpoint.Parameters) + { + ProcessParameter(parameter, codeWriter, ref serviceProviderEmitted); + if (parameter is { Source: EndpointParameterSource.AsParameters, EndpointParameters: {} innerParameters }) + { + foreach (var innerParameter in innerParameters) + { + ProcessParameter(innerParameter, codeWriter, ref serviceProviderEmitted); + } + } + } + + static void ProcessParameter(EndpointParameter parameter, CodeWriter codeWriter, ref bool serviceProviderEmitted) + { + if (parameter.Source == EndpointParameterSource.JsonBodyOrService) + { + if (!serviceProviderEmitted) + { + codeWriter.WriteLine("var serviceProviderIsService = serviceProvider?.GetService();"); + serviceProviderEmitted = true; + } + codeWriter.Write($@"var {parameter.SymbolName}_JsonBodyOrServiceResolver = "); + var shortParameterTypeName = parameter.Type.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat); + codeWriter.WriteLine($"ResolveJsonBodyOrService<{parameter.Type.ToDisplayString(EmitterConstants.DisplayFormat)}>(logOrThrowExceptionHelper, {SymbolDisplay.FormatLiteral(shortParameterTypeName, true)}, {SymbolDisplay.FormatLiteral(parameter.SymbolName, true)}, serviceProviderIsService);"); + } + } + } + + /* + * Emits parameter preparation for a parameter + * of a given source. + */ + private static void EmitSpecialParameterPreparation(this EndpointParameter endpointParameter, CodeWriter codeWriter) => codeWriter.WriteLine($"var {endpointParameter.EmitHandlerArgument()} = {endpointParameter.AssigningCode};"); - internal static void EmitQueryOrHeaderParameterPreparation(this EndpointParameter endpointParameter, CodeWriter codeWriter) + private static void EmitQueryOrHeaderParameterPreparation(this EndpointParameter endpointParameter, CodeWriter codeWriter) { codeWriter.WriteLine(endpointParameter.EmitParameterDiagnosticComment()); @@ -52,7 +177,7 @@ internal static void EmitQueryOrHeaderParameterPreparation(this EndpointParamete endpointParameter.EmitParsingBlock(codeWriter); } - internal static void EmitFormParameterPreparation(this EndpointParameter endpointParameter, CodeWriter codeWriter, ref bool readFormEmitted) + private static void EmitFormParameterPreparation(this EndpointParameter endpointParameter, CodeWriter codeWriter, ref bool readFormEmitted) { codeWriter.WriteLine(endpointParameter.EmitParameterDiagnosticComment()); @@ -87,7 +212,7 @@ internal static void EmitFormParameterPreparation(this EndpointParameter endpoin endpointParameter.EmitParsingBlock(codeWriter); } - internal static void EmitParsingBlock(this EndpointParameter endpointParameter, CodeWriter codeWriter) + private static void EmitParsingBlock(this EndpointParameter endpointParameter, CodeWriter codeWriter) { if (endpointParameter.IsArray && endpointParameter.IsParsable) { @@ -124,7 +249,7 @@ internal static void EmitParsingBlock(this EndpointParameter endpointParameter, } } - internal static void EmitRouteParameterPreparation(this EndpointParameter endpointParameter, CodeWriter codeWriter) + private static void EmitRouteParameterPreparation(this EndpointParameter endpointParameter, CodeWriter codeWriter) { codeWriter.WriteLine(endpointParameter.EmitParameterDiagnosticComment()); @@ -151,7 +276,7 @@ internal static void EmitRouteParameterPreparation(this EndpointParameter endpoi endpointParameter.EmitParsingBlock(codeWriter); } - internal static void EmitRouteOrQueryParameterPreparation(this EndpointParameter endpointParameter, CodeWriter codeWriter) + private static void EmitRouteOrQueryParameterPreparation(this EndpointParameter endpointParameter, CodeWriter codeWriter) { codeWriter.WriteLine(endpointParameter.EmitParameterDiagnosticComment()); @@ -182,7 +307,7 @@ internal static void EmitRouteOrQueryParameterPreparation(this EndpointParameter endpointParameter.EmitParsingBlock(codeWriter); } - internal static void EmitJsonBodyParameterPreparationString(this EndpointParameter endpointParameter, CodeWriter codeWriter) + private static void EmitJsonBodyParameterPreparationString(this EndpointParameter endpointParameter, CodeWriter codeWriter) { // Preamble for diagnostics purposes. codeWriter.WriteLine(endpointParameter.EmitParameterDiagnosticComment()); @@ -204,7 +329,7 @@ internal static void EmitJsonBodyParameterPreparationString(this EndpointParamet codeWriter.EndBlock(); } - internal static void EmitJsonBodyOrServiceParameterPreparationString(this EndpointParameter endpointParameter, CodeWriter codeWriter) + private static void EmitJsonBodyOrServiceParameterPreparationString(this EndpointParameter endpointParameter, CodeWriter codeWriter) { // Preamble for diagnostics purposes. codeWriter.WriteLine(endpointParameter.EmitParameterDiagnosticComment()); @@ -225,7 +350,7 @@ internal static void EmitJsonBodyOrServiceParameterPreparationString(this Endpoi codeWriter.EndBlock(); } - internal static void EmitBindAsyncPreparation(this EndpointParameter endpointParameter, CodeWriter codeWriter) + private static void EmitBindAsyncPreparation(this EndpointParameter endpointParameter, CodeWriter codeWriter) { var unwrappedType = endpointParameter.Type.UnwrapTypeSymbol(unwrapNullable: true); var unwrappedTypeString = unwrappedType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat); @@ -269,7 +394,7 @@ internal static void EmitBindAsyncPreparation(this EndpointParameter endpointPar } } - internal static void EmitServiceParameterPreparation(this EndpointParameter endpointParameter, CodeWriter codeWriter) + private static void EmitServiceParameterPreparation(this EndpointParameter endpointParameter, CodeWriter codeWriter) { codeWriter.WriteLine(endpointParameter.EmitParameterDiagnosticComment()); @@ -283,17 +408,156 @@ internal static void EmitServiceParameterPreparation(this EndpointParameter endp codeWriter.WriteLine($"var {endpointParameter.EmitHandlerArgument()} = {assigningCode};"); } - internal static void EmitAsParametersParameterPreparation(this EndpointParameter endpointParameter, CodeWriter codeWriter, EmitterContext emitterContext) + private static void EmitAsParametersParameterPreparation(this EndpointParameter endpointParameter, CodeWriter codeWriter, EmitterContext emitterContext) { codeWriter.WriteLine(endpointParameter.EmitParameterDiagnosticComment()); codeWriter.WriteLine(endpointParameter.EndpointParameters?.EmitParameterPreparation(baseIndent: codeWriter.Indent, emitterContext: emitterContext)); codeWriter.WriteLine($"var {endpointParameter.EmitHandlerArgument()} = {endpointParameter.AssigningCode};"); } + /* + * Emitters for metadata-related aspects of parameters, such as invoking + * IEndpointParameterMetadataProviders, annotating metadata for form + * and JSON content types, and so on. + */ + public static void EmitCallsToMetadataProvidersForParameters(this Endpoint endpoint, CodeWriter codeWriter) + { + if (endpoint.EmitterContext.HasEndpointParameterMetadataProvider) + { + codeWriter.WriteLine("var parameterInfos = methodInfo.GetParameters();"); + } + + foreach (var parameter in endpoint.Parameters) + { + if (parameter is { Source: EndpointParameterSource.AsParameters, EndpointParameters: { } innerParameters }) + { + foreach (var innerParameter in innerParameters) + { + ProcessParameter(innerParameter, codeWriter); + } + } + else + { + ProcessParameter(parameter, codeWriter); + } + } + + static void ProcessParameter(EndpointParameter parameter, CodeWriter codeWriter) + { + if (parameter.Type is not { } parameterType) + { + return; + } + + if (parameter.IsEndpointParameterMetadataProvider) + { + var resolveParameterInfo = parameter.IsProperty + ? parameter.PropertyAsParameterInfoConstruction + : $"parameterInfos[{parameter.Ordinal}]"; + codeWriter.WriteLine($"var {parameter.SymbolName}_ParameterInfo = {resolveParameterInfo};"); + codeWriter.WriteLine($"PopulateMetadataForParameter<{parameterType.ToDisplayString(EmitterConstants.DisplayFormat)}>({parameter.SymbolName}_ParameterInfo, options.EndpointBuilder);"); + } + + if (parameter.IsEndpointMetadataProvider) + { + codeWriter.WriteLine($"PopulateMetadataForEndpoint<{parameterType.ToDisplayString(EmitterConstants.DisplayFormat)}>(methodInfo, options.EndpointBuilder);"); + } + + } + } + + private static void EmitFormAcceptsMetadata(this Endpoint endpoint, CodeWriter codeWriter) + { + var hasFormFiles = endpoint.Parameters.Any(p => p.IsFormFile); + + if (hasFormFiles) + { + codeWriter.WriteLine("options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(contentTypes: GeneratedMetadataConstants.FormFileContentType));"); + } + else + { + codeWriter.WriteLine("options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(contentTypes: GeneratedMetadataConstants.FormContentType));"); + } + } + + private static void EmitJsonAcceptsMetadata(this Endpoint endpoint, CodeWriter codeWriter) + { + EndpointParameter? explicitBodyParameter = null; + var potentialImplicitBodyParameters = new List(); + + foreach (var parameter in endpoint.Parameters) + { + if (explicitBodyParameter == null && parameter.Source == EndpointParameterSource.JsonBody) + { + explicitBodyParameter = parameter; + break; + } + else if (parameter.Source == EndpointParameterSource.JsonBodyOrService) + { + potentialImplicitBodyParameters.Add(parameter); + } + } + + if (explicitBodyParameter != null) + { + codeWriter.WriteLine($$"""options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(type: typeof({{explicitBodyParameter.Type.ToDisplayString(EmitterConstants.DisplayFormatWithoutNullability)}}), isOptional: {{(explicitBodyParameter.IsOptional ? "true" : "false")}}, contentTypes: GeneratedMetadataConstants.JsonContentType));"""); + } + else if (potentialImplicitBodyParameters.Count > 0) + { + codeWriter.WriteLine("var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices;"); + codeWriter.WriteLine($"var serviceProviderIsService = serviceProvider.GetRequiredService();"); + + codeWriter.WriteLine("var jsonBodyOrServiceTypeTuples = new (bool, Type)[] {"); + codeWriter.Indent++; + foreach (var parameter in potentialImplicitBodyParameters) + { + codeWriter.WriteLine($$"""({{(parameter.IsOptional ? "true" : "false")}}, typeof({{parameter.Type.ToDisplayString(EmitterConstants.DisplayFormatWithoutNullability)}})),"""); + } + codeWriter.Indent--; + codeWriter.WriteLine("};"); + codeWriter.WriteLine("foreach (var (isOptional, type) in jsonBodyOrServiceTypeTuples)"); + codeWriter.StartBlock(); + codeWriter.WriteLine("if (!serviceProviderIsService.IsService(type))"); + codeWriter.StartBlock(); + codeWriter.WriteLine("options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(type: type, isOptional: isOptional, contentTypes: GeneratedMetadataConstants.JsonContentType));"); + codeWriter.WriteLine("break;"); + codeWriter.EndBlock(); + codeWriter.EndBlock(); + } + else + { + codeWriter.WriteLine($"options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(contentTypes: GeneratedMetadataConstants.JsonContentType));"); + } + } + + public static void EmitAcceptsMetadata(this Endpoint endpoint, CodeWriter codeWriter) + { + var hasJsonBody = endpoint.EmitterContext.HasJsonBody || endpoint.EmitterContext.HasJsonBodyOrService; + + if (endpoint.EmitterContext.HasFormBody) + { + endpoint.EmitFormAcceptsMetadata(codeWriter); + } + else if (hasJsonBody) + { + endpoint.EmitJsonAcceptsMetadata(codeWriter); + } + } + + /* + * Helpers that are used for parameter preparation code. + */ private static string EmitParameterDiagnosticComment(this EndpointParameter endpointParameter) => $"// Endpoint Parameter: {endpointParameter.SymbolName} (Type = {endpointParameter.Type}, IsOptional = {endpointParameter.IsOptional}, IsParsable = {endpointParameter.IsParsable}, IsArray = {endpointParameter.IsArray}, Source = {endpointParameter.Source})"; private static string EmitTempArgument(this EndpointParameter endpointParameter) => $"{endpointParameter.SymbolName}_temp"; private static string EmitParsedTempArgument(this EndpointParameter endpointParameter) => $"{endpointParameter.SymbolName}_parsed_temp"; private static string EmitAssigningCodeResult(this EndpointParameter endpointParameter) => $"{endpointParameter.SymbolName}_raw"; + public static void EmitLoggingPreamble(this Endpoint endpoint, CodeWriter codeWriter) + { + if (endpoint.EmitterContext.RequiresLoggingHelper) + { + codeWriter.WriteLine("var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options);"); + } + } } diff --git a/src/Http/Http.Extensions/gen/StaticRouteHandler/Emitters/EndpointResponseEmitter.cs b/src/Http/Http.Extensions/gen/StaticRouteHandler/Emitters/EndpointResponseEmitter.cs new file mode 100644 index 000000000000..433c1fddb377 --- /dev/null +++ b/src/Http/Http.Extensions/gen/StaticRouteHandler/Emitters/EndpointResponseEmitter.cs @@ -0,0 +1,92 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Model; +using Microsoft.CodeAnalysis; +namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Emitters; + +internal static class EndpointResponseEmitter +{ + internal static void EmitJsonPreparation(this EndpointResponse endpointResponse, CodeWriter codeWriter) + { + if (endpointResponse.IsSerializableJsonResponse(out var responseType)) + { + var typeName = responseType.ToDisplayString(EmitterConstants.DisplayFormat); + + codeWriter.WriteLine("var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions;"); + codeWriter.WriteLine($"var jsonTypeInfo = (JsonTypeInfo<{typeName}>)serializerOptions.GetTypeInfo(typeof({typeName}));"); + } + } + + private static string EmitJsonResponse(this EndpointResponse endpointResponse) + { + if (endpointResponse.ResponseType != null && + (endpointResponse.ResponseType.IsSealed || endpointResponse.ResponseType.IsValueType)) + { + return $"httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo);"; + } + return $"GeneratedRouteBuilderExtensionsCore.WriteToResponseAsync(result, httpContext, jsonTypeInfo);"; + } + + internal static string EmitResponseWritingCall(this EndpointResponse endpointResponse, bool isAwaitable) + { + var returnOrAwait = isAwaitable ? "await" : "return"; + + if (endpointResponse.IsIResult) + { + return $"{returnOrAwait} GeneratedRouteBuilderExtensionsCore.ExecuteAsyncExplicit(result, httpContext);"; + } + if (endpointResponse.ResponseType?.SpecialType == SpecialType.System_String) + { + return $"{returnOrAwait} httpContext.Response.WriteAsync(result);"; + } + if (endpointResponse.ResponseType?.SpecialType == SpecialType.System_Object) + { + return $"{returnOrAwait} GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext);"; + } + if (!endpointResponse.HasNoResponse) + { + return $"{returnOrAwait} {endpointResponse.EmitJsonResponse()}"; + } + if (!endpointResponse.IsAwaitable && endpointResponse.HasNoResponse) + { + return $"{returnOrAwait} Task.CompletedTask;"; + } + return $"{returnOrAwait} httpContext.Response.WriteAsync(result);"; + } + + internal static void EmitBuiltinResponseTypeMetadata(this Endpoint endpoint, CodeWriter codeWriter) + { + if (endpoint.Response is not { } response || response.ResponseType is not { } responseType) + { + return; + } + + if (response.HasNoResponse || response.IsIResult) + { + return; + } + + if (responseType.SpecialType == SpecialType.System_String) + { + codeWriter.WriteLine("options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType));"); + } + else + { + codeWriter.WriteLine($"options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof({responseType.ToDisplayString(EmitterConstants.DisplayFormat)}), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType));"); + } + } + + internal static void EmitCallToMetadataProviderForResponse(this Endpoint endpoint, CodeWriter codeWriter) + { + if (endpoint.Response is not { } response || response.ResponseType is not { } responseType) + { + return; + } + + if (response.IsEndpointMetadataProvider) + { + codeWriter.WriteLine($"PopulateMetadataForEndpoint<{responseType.ToDisplayString(EmitterConstants.DisplayFormat)}>(methodInfo, options.EndpointBuilder);"); + } + } +} diff --git a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Model/ConstructorParameter.cs b/src/Http/Http.Extensions/gen/StaticRouteHandler/Model/ConstructorParameter.cs similarity index 93% rename from src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Model/ConstructorParameter.cs rename to src/Http/Http.Extensions/gen/StaticRouteHandler/Model/ConstructorParameter.cs index 82fee4e2020f..6c1ec5b48b08 100644 --- a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Model/ConstructorParameter.cs +++ b/src/Http/Http.Extensions/gen/StaticRouteHandler/Model/ConstructorParameter.cs @@ -2,6 +2,6 @@ // The .NET Foundation licenses this file to you under the MIT license. using Microsoft.CodeAnalysis; -namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel; +namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Model; internal record ConstructorParameter(IPropertySymbol Property, IParameterSymbol? Parameter); diff --git a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Endpoint.cs b/src/Http/Http.Extensions/gen/StaticRouteHandler/Model/Endpoint.cs similarity index 91% rename from src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Endpoint.cs rename to src/Http/Http.Extensions/gen/StaticRouteHandler/Model/Endpoint.cs index 752ed5ac9605..b812d19bfa5e 100644 --- a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Endpoint.cs +++ b/src/Http/Http.Extensions/gen/StaticRouteHandler/Model/Endpoint.cs @@ -6,12 +6,12 @@ using System.Linq; using Microsoft.AspNetCore.Analyzers.Infrastructure; using Microsoft.AspNetCore.App.Analyzers.Infrastructure; -using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel.Emitters; +using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Emitters; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; using Microsoft.CodeAnalysis.Operations; -namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel; +namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Model; internal class Endpoint { @@ -104,7 +104,7 @@ public Endpoint(IInvocationOperation operation, WellKnownTypes wellKnownTypes, S public EndpointParameter[] Parameters { get; } = Array.Empty(); public List Diagnostics { get; } = new List(); - public (string File, int LineNumber) Location { get; } + public (string File, int LineNumber, int CharaceterNumber) Location { get; } public IInvocationOperation Operation { get; } public override bool Equals(object o) => @@ -147,13 +147,16 @@ public static int GetSignatureHashCode(Endpoint endpoint) return hashCode.ToHashCode(); } - private static (string, int) GetLocation(IInvocationOperation operation) + private static (string, int, int) GetLocation(IInvocationOperation operation) { var operationSpan = operation.Syntax.Span; var filePath = operation.Syntax.SyntaxTree.GetDisplayPath(operationSpan, operation.SemanticModel?.Compilation.Options.SourceReferenceResolver); var span = operation.Syntax.SyntaxTree.GetLineSpan(operationSpan); var lineNumber = span.StartLinePosition.Line + 1; - return (filePath, lineNumber); + // Calculate the character offset to the end of the Map invocation detected + var invocationLength = ((MemberAccessExpressionSyntax)((InvocationExpressionSyntax)operation.Syntax).Expression).Expression.Span.Length; + var characterNumber = span.StartLinePosition.Character + invocationLength + 1; + return (filePath, lineNumber, characterNumber); } private static string GetHttpMethod(IInvocationOperation operation) diff --git a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/EndpointDelegateComparer.cs b/src/Http/Http.Extensions/gen/StaticRouteHandler/Model/EndpointDelegateComparer.cs similarity index 96% rename from src/Http/Http.Extensions/gen/StaticRouteHandlerModel/EndpointDelegateComparer.cs rename to src/Http/Http.Extensions/gen/StaticRouteHandler/Model/EndpointDelegateComparer.cs index c960a870613f..5cbdf81d326c 100644 --- a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/EndpointDelegateComparer.cs +++ b/src/Http/Http.Extensions/gen/StaticRouteHandler/Model/EndpointDelegateComparer.cs @@ -3,7 +3,7 @@ using System.Collections.Generic; -namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel; +namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Model; internal sealed class EndpointDelegateComparer : IEqualityComparer { diff --git a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/EndpointParameter.cs b/src/Http/Http.Extensions/gen/StaticRouteHandler/Model/EndpointParameter.cs similarity index 99% rename from src/Http/Http.Extensions/gen/StaticRouteHandlerModel/EndpointParameter.cs rename to src/Http/Http.Extensions/gen/StaticRouteHandler/Model/EndpointParameter.cs index 940d643f0d3d..1de43b42c8ab 100644 --- a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/EndpointParameter.cs +++ b/src/Http/Http.Extensions/gen/StaticRouteHandler/Model/EndpointParameter.cs @@ -10,11 +10,12 @@ using Microsoft.AspNetCore.Analyzers.Infrastructure; using Microsoft.AspNetCore.Analyzers.RouteEmbeddedLanguage.Infrastructure; using Microsoft.AspNetCore.App.Analyzers.Infrastructure; +using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Emitters; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using WellKnownType = Microsoft.AspNetCore.App.Analyzers.Infrastructure.WellKnownTypeData.WellKnownType; -namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel; +namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Model; internal class EndpointParameter { @@ -22,6 +23,7 @@ public EndpointParameter(Endpoint endpoint, IParameterSymbol parameter, WellKnow { Ordinal = parameter.Ordinal; IsOptional = parameter.IsOptional(); + HasDefaultValue = parameter.HasExplicitDefaultValue; DefaultValue = parameter.GetDefaultValueString(); ProcessEndpointParameterSource(endpoint, parameter, parameter.GetAttributes(), wellKnownTypes); } @@ -31,6 +33,7 @@ private EndpointParameter(Endpoint endpoint, IPropertySymbol property, IParamete Ordinal = parameter?.Ordinal ?? 0; IsProperty = true; IsOptional = property.IsOptional() || parameter?.IsOptional() == true; + HasDefaultValue = parameter?.HasExplicitDefaultValue ?? false; DefaultValue = parameter?.GetDefaultValueString() ?? "null"; // Coalesce attributes on the property and attributes on the matching parameter var attributeBuilder = ImmutableArray.CreateBuilder(); @@ -256,6 +259,7 @@ private static bool ShouldDisableInferredBodyParameters(string httpMethod) public bool IsOptional { get; set; } public bool IsArray { get; set; } public string DefaultValue { get; set; } = "null"; + public bool HasDefaultValue { get; set; } [MemberNotNullWhen(true, nameof(PropertyAsParameterInfoConstruction))] public bool IsProperty { get; set; } public EndpointParameterSource Source { get; set; } diff --git a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/EndpointParameterSource.cs b/src/Http/Http.Extensions/gen/StaticRouteHandler/Model/EndpointParameterSource.cs similarity index 97% rename from src/Http/Http.Extensions/gen/StaticRouteHandlerModel/EndpointParameterSource.cs rename to src/Http/Http.Extensions/gen/StaticRouteHandler/Model/EndpointParameterSource.cs index 5a545a831dc0..3c691a8f27f3 100644 --- a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/EndpointParameterSource.cs +++ b/src/Http/Http.Extensions/gen/StaticRouteHandler/Model/EndpointParameterSource.cs @@ -1,7 +1,7 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel; +namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Model; internal enum EndpointParameterSource { diff --git a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/EndpointResponse.cs b/src/Http/Http.Extensions/gen/StaticRouteHandler/Model/EndpointResponse.cs similarity index 99% rename from src/Http/Http.Extensions/gen/StaticRouteHandlerModel/EndpointResponse.cs rename to src/Http/Http.Extensions/gen/StaticRouteHandler/Model/EndpointResponse.cs index e518c47171e6..42008a2dc226 100644 --- a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/EndpointResponse.cs +++ b/src/Http/Http.Extensions/gen/StaticRouteHandler/Model/EndpointResponse.cs @@ -5,10 +5,10 @@ using System.Linq; using Microsoft.AspNetCore.Analyzers.RouteEmbeddedLanguage.Infrastructure; using Microsoft.AspNetCore.App.Analyzers.Infrastructure; -using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel.Emitters; +using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Emitters; using Microsoft.CodeAnalysis; -namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel; +namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Model; using WellKnownType = WellKnownTypeData.WellKnownType; diff --git a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/InvocationOperationExtensions.cs b/src/Http/Http.Extensions/gen/StaticRouteHandler/Model/InvocationOperationExtensions.cs similarity index 99% rename from src/Http/Http.Extensions/gen/StaticRouteHandlerModel/InvocationOperationExtensions.cs rename to src/Http/Http.Extensions/gen/StaticRouteHandler/Model/InvocationOperationExtensions.cs index bc31e52b9990..a59ab17a74a0 100644 --- a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/InvocationOperationExtensions.cs +++ b/src/Http/Http.Extensions/gen/StaticRouteHandler/Model/InvocationOperationExtensions.cs @@ -6,7 +6,7 @@ using Microsoft.CodeAnalysis.CSharp.Syntax; using Microsoft.CodeAnalysis.Operations; -namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel; +namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Model; internal static class InvocationOperationExtensions { diff --git a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Model/ParameterLookupKey.cs b/src/Http/Http.Extensions/gen/StaticRouteHandler/Model/ParameterLookupKey.cs similarity index 97% rename from src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Model/ParameterLookupKey.cs rename to src/Http/Http.Extensions/gen/StaticRouteHandler/Model/ParameterLookupKey.cs index 55da4a664165..7615bc0863a4 100644 --- a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Model/ParameterLookupKey.cs +++ b/src/Http/Http.Extensions/gen/StaticRouteHandler/Model/ParameterLookupKey.cs @@ -5,7 +5,7 @@ using System.Diagnostics.CodeAnalysis; using Microsoft.CodeAnalysis; -namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel; +namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Model; internal sealed class ParameterLookupKey { diff --git a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Emitters/EndpointEmitter.cs b/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Emitters/EndpointEmitter.cs deleted file mode 100644 index ec30c03b7e11..000000000000 --- a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Emitters/EndpointEmitter.cs +++ /dev/null @@ -1,129 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Collections.Generic; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using System.Globalization; -using System.IO; -using System.Linq; - -namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel.Emitters; -internal static class EndpointEmitter -{ - internal static string EmitParameterPreparation(this IEnumerable endpointParameters, EmitterContext emitterContext, int baseIndent = 0) - { - using var stringWriter = new StringWriter(CultureInfo.InvariantCulture); - using var parameterPreparationBuilder = new CodeWriter(stringWriter, baseIndent); - var readFormEmitted = false; - - foreach (var parameter in endpointParameters) - { - switch (parameter.Source) - { - case EndpointParameterSource.SpecialType: - parameter.EmitSpecialParameterPreparation(parameterPreparationBuilder); - break; - case EndpointParameterSource.Query: - case EndpointParameterSource.Header: - parameter.EmitQueryOrHeaderParameterPreparation(parameterPreparationBuilder); - break; - case EndpointParameterSource.Route: - parameter.EmitRouteParameterPreparation(parameterPreparationBuilder); - break; - case EndpointParameterSource.RouteOrQuery: - emitterContext.HasRouteOrQuery = true; - parameter.EmitRouteOrQueryParameterPreparation(parameterPreparationBuilder); - break; - case EndpointParameterSource.BindAsync: - emitterContext.HasBindAsync = true; - parameter.EmitBindAsyncPreparation(parameterPreparationBuilder); - break; - case EndpointParameterSource.JsonBody: - parameter.EmitJsonBodyParameterPreparationString(parameterPreparationBuilder); - break; - case EndpointParameterSource.FormBody: - parameter.EmitFormParameterPreparation(parameterPreparationBuilder, ref readFormEmitted); - break; - case EndpointParameterSource.JsonBodyOrService: - parameter.EmitJsonBodyOrServiceParameterPreparationString(parameterPreparationBuilder); - break; - case EndpointParameterSource.Service: - parameter.EmitServiceParameterPreparation(parameterPreparationBuilder); - break; - case EndpointParameterSource.AsParameters: - parameter.EmitAsParametersParameterPreparation(parameterPreparationBuilder, emitterContext); - break; - } - } - - return stringWriter.ToString(); - } - - public static void EmitRouteOrQueryResolver(this Endpoint endpoint, CodeWriter codeWriter) - { - foreach (var parameter in endpoint.Parameters) - { - ProcessParameter(parameter, codeWriter, endpoint); - if (parameter is { Source: EndpointParameterSource.AsParameters, EndpointParameters: {} innerParameters }) - { - foreach (var innerParameter in innerParameters) - { - ProcessParameter(innerParameter, codeWriter, endpoint); - } - } - } - - static void ProcessParameter(EndpointParameter parameter, CodeWriter codeWriter, Endpoint endpoint) - { - if (parameter.Source == EndpointParameterSource.RouteOrQuery) - { - var parameterName = parameter.SymbolName; - codeWriter.Write($@"var {parameterName}_RouteOrQueryResolver = "); - codeWriter.WriteLine($@"GeneratedRouteBuilderExtensionsCore.ResolveFromRouteOrQuery(""{parameterName}"", options?.RouteParameterNames);"); - endpoint.EmitterContext.HasRouteOrQuery = true; - } - } - } - - public static void EmitJsonBodyOrServiceResolver(this Endpoint endpoint, CodeWriter codeWriter) - { - var serviceProviderEmitted = false; - foreach (var parameter in endpoint.Parameters) - { - ProcessParameter(parameter, codeWriter, ref serviceProviderEmitted); - if (parameter is { Source: EndpointParameterSource.AsParameters, EndpointParameters: {} innerParameters }) - { - foreach (var innerParameter in innerParameters) - { - ProcessParameter(innerParameter, codeWriter, ref serviceProviderEmitted); - } - } - } - - static void ProcessParameter(EndpointParameter parameter, CodeWriter codeWriter, ref bool serviceProviderEmitted) - { - if (parameter.Source == EndpointParameterSource.JsonBodyOrService) - { - if (!serviceProviderEmitted) - { - codeWriter.WriteLine("var serviceProviderIsService = serviceProvider?.GetService();"); - serviceProviderEmitted = true; - } - codeWriter.Write($@"var {parameter.SymbolName}_JsonBodyOrServiceResolver = "); - var shortParameterTypeName = parameter.Type.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat); - codeWriter.WriteLine($"ResolveJsonBodyOrService<{parameter.Type.ToDisplayString(EmitterConstants.DisplayFormat)}>(logOrThrowExceptionHelper, {SymbolDisplay.FormatLiteral(shortParameterTypeName, true)}, {SymbolDisplay.FormatLiteral(parameter.SymbolName, true)}, serviceProviderIsService);"); - } - } - } - - public static void EmitLoggingPreamble(this Endpoint endpoint, CodeWriter codeWriter) - { - if (endpoint.EmitterContext.RequiresLoggingHelper) - { - codeWriter.WriteLine("var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options);"); - } - } - - public static string EmitArgumentList(this Endpoint endpoint) => string.Join(", ", endpoint.Parameters.Select(p => p.EmitArgument())); -} diff --git a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Emitters/EndpointJsonResponseEmitter.cs b/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Emitters/EndpointJsonResponseEmitter.cs deleted file mode 100644 index 3694de260f88..000000000000 --- a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Emitters/EndpointJsonResponseEmitter.cs +++ /dev/null @@ -1,28 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel.Emitters; - -internal static class EndpointJsonResponseEmitter -{ - internal static void EmitJsonPreparation(this EndpointResponse endpointResponse, CodeWriter codeWriter) - { - if (endpointResponse.IsSerializableJsonResponse(out var responseType)) - { - var typeName = responseType.ToDisplayString(EmitterConstants.DisplayFormat); - - codeWriter.WriteLine("var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions;"); - codeWriter.WriteLine($"var jsonTypeInfo = (JsonTypeInfo<{typeName}>)serializerOptions.GetTypeInfo(typeof({typeName}));"); - } - } - - internal static string EmitJsonResponse(this EndpointResponse endpointResponse) - { - if (endpointResponse.ResponseType != null && - (endpointResponse.ResponseType.IsSealed || endpointResponse.ResponseType.IsValueType)) - { - return $"httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo);"; - } - return $"GeneratedRouteBuilderExtensionsCore.WriteToResponseAsync(result, httpContext, jsonTypeInfo);"; - } -} diff --git a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/StaticRouteHandlerModel.Emitter.cs b/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/StaticRouteHandlerModel.Emitter.cs deleted file mode 100644 index 0c0d11fecb02..000000000000 --- a/src/Http/Http.Extensions/gen/StaticRouteHandlerModel/StaticRouteHandlerModel.Emitter.cs +++ /dev/null @@ -1,401 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel.Emitters; -using Microsoft.CodeAnalysis; - -namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel; - -internal static class StaticRouteHandlerModelEmitter -{ - public static string EmitHandlerDelegateType(this Endpoint endpoint, bool considerOptionality = false) - { - if (endpoint.Parameters.Length == 0) - { - return endpoint.Response == null || (endpoint.Response.HasNoResponse && !endpoint.Response.IsAwaitable) ? "System.Action" : $"System.Func<{endpoint.Response.WrappedResponseType}>"; - } - var parameterTypeList = string.Join(", ", endpoint.Parameters.Select(p => considerOptionality - ? p.Type.ToDisplayString(p.IsOptional ? NullableFlowState.MaybeNull : NullableFlowState.NotNull, EmitterConstants.DisplayFormat) - : p.Type.ToDisplayString(EmitterConstants.DisplayFormat))); - - if (endpoint.Response == null || (endpoint.Response.HasNoResponse && !endpoint.Response.IsAwaitable)) - { - return $"System.Action<{parameterTypeList}>"; - } - return $"System.Func<{parameterTypeList}, {endpoint.Response.WrappedResponseType}>"; - } - - public static string EmitSourceKey(this Endpoint endpoint) - { - return $@"(@""{endpoint.Location.File}"", {endpoint.Location.LineNumber})"; - } - - public static string EmitVerb(this Endpoint endpoint) - { - return endpoint.HttpMethod switch - { - "MapGet" => "GetVerb", - "MapPut" => "PutVerb", - "MapPost" => "PostVerb", - "MapDelete" => "DeleteVerb", - "MapPatch" => "PatchVerb", - "MapMethods" => "httpMethods", - "Map" => "null", - "MapFallback" => "null", - _ => throw new ArgumentException($"Received unexpected HTTP method: {endpoint.HttpMethod}") - }; - } - - /* - * Emit invocation to the request handler. The structure - * involved here consists of a call to bind parameters, check - * their validity (optionality), invoke the underlying handler with - * the arguments bound from HTTP context, and write out the response. - */ - public static void EmitRequestHandler(this Endpoint endpoint, CodeWriter codeWriter) - { - codeWriter.WriteLine(endpoint.IsAwaitable ? "async Task RequestHandler(HttpContext httpContext)" : "Task RequestHandler(HttpContext httpContext)"); - codeWriter.StartBlock(); // Start handler method block - codeWriter.WriteLine("var wasParamCheckFailure = false;"); - - if (endpoint.Parameters.Length > 0) - { - codeWriter.WriteLine(endpoint.Parameters.EmitParameterPreparation(endpoint.EmitterContext, codeWriter.Indent)); - } - - codeWriter.WriteLine("if (wasParamCheckFailure)"); - codeWriter.StartBlock(); // Start if-statement block - codeWriter.WriteLine("httpContext.Response.StatusCode = 400;"); - codeWriter.WriteLine(endpoint.IsAwaitable ? "return;" : "return Task.CompletedTask;"); - codeWriter.EndBlock(); // End if-statement block - if (endpoint.Response == null) - { - return; - } - if (!endpoint.Response.HasNoResponse && endpoint.Response is { ContentType: { } contentType }) - { - codeWriter.WriteLine($@"httpContext.Response.ContentType ??= ""{contentType}"";"); - } - if (!endpoint.Response.HasNoResponse) - { - codeWriter.Write("var result = "); - } - if (endpoint.Response.IsAwaitable) - { - codeWriter.Write("await "); - } - codeWriter.WriteLine($"handler({endpoint.EmitArgumentList()});"); - if (!endpoint.Response.HasNoResponse) - { - codeWriter.WriteLine(endpoint.Response.EmitResponseWritingCall(endpoint.IsAwaitable)); - } - else if (!endpoint.IsAwaitable) - { - codeWriter.WriteLine("return Task.CompletedTask;"); - } - codeWriter.EndBlock(); // End handler method block - } - - private static string EmitResponseWritingCall(this EndpointResponse endpointResponse, bool isAwaitable) - { - var returnOrAwait = isAwaitable ? "await" : "return"; - - if (endpointResponse.IsIResult) - { - return $"{returnOrAwait} GeneratedRouteBuilderExtensionsCore.ExecuteAsyncExplicit(result, httpContext);"; - } - else if (endpointResponse.ResponseType?.SpecialType == SpecialType.System_String) - { - return $"{returnOrAwait} httpContext.Response.WriteAsync(result);"; - } - else if (endpointResponse.ResponseType?.SpecialType == SpecialType.System_Object) - { - return $"{returnOrAwait} GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext);"; - } - else if (!endpointResponse.HasNoResponse) - { - return $"{returnOrAwait} {endpointResponse.EmitJsonResponse()}"; - } - else if (!endpointResponse.IsAwaitable && endpointResponse.HasNoResponse) - { - return $"{returnOrAwait} Task.CompletedTask;"; - } - else - { - return $"{returnOrAwait} httpContext.Response.WriteAsync(result);"; - } - } - - /* - * TODO: Emit invocation to the `filteredInvocation` pipeline by constructing - * the `EndpointFilterInvocationContext` using the bound arguments for the handler. - * In the source generator context, the generic overloads for `EndpointFilterInvocationContext` - * can be used to reduce the boxing that happens at runtime when constructing - * the context object. - */ - public static void EmitFilteredRequestHandler(this Endpoint endpoint, CodeWriter codeWriter) - { - var argumentList = endpoint.Parameters.Length == 0 ? string.Empty : $", {endpoint.EmitArgumentList()}"; - var invocationCreator = endpoint.Parameters.Length > 8 - ? "new DefaultEndpointFilterInvocationContext" - : "EndpointFilterInvocationContext.Create"; - var invocationGenericArgs = endpoint.Parameters.Length is > 0 and < 8 - ? $"<{endpoint.EmitFilterInvocationContextTypeArgs()}>" - : string.Empty; - - codeWriter.WriteLine("async Task RequestHandlerFiltered(HttpContext httpContext)"); - codeWriter.StartBlock(); // Start handler method block - codeWriter.WriteLine("var wasParamCheckFailure = false;"); - - if (endpoint.Parameters.Length > 0) - { - codeWriter.WriteLine(endpoint.Parameters.EmitParameterPreparation(endpoint.EmitterContext, codeWriter.Indent)); - } - - codeWriter.WriteLine("if (wasParamCheckFailure)"); - codeWriter.StartBlock(); // Start if-statement block - codeWriter.WriteLine("httpContext.Response.StatusCode = 400;"); - codeWriter.EndBlock(); // End if-statement block - codeWriter.WriteLine($"var result = await filteredInvocation({invocationCreator}{invocationGenericArgs}(httpContext{argumentList}));"); - codeWriter.WriteLine("await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext);"); - codeWriter.EndBlock(); // End handler method block - } - - private static void EmitBuiltinResponseTypeMetadata(this Endpoint endpoint, CodeWriter codeWriter) - { - if (endpoint.Response is not { } response || response.ResponseType is not { } responseType) - { - return; - } - - if (response.HasNoResponse || response.IsIResult) - { - return; - } - - if (responseType.SpecialType == SpecialType.System_String) - { - codeWriter.WriteLine("options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType));"); - } - else - { - codeWriter.WriteLine($"options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof({responseType.ToDisplayString(EmitterConstants.DisplayFormat)}), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType));"); - } - } - - private static void EmitCallToMetadataProviderForResponse(this Endpoint endpoint, CodeWriter codeWriter) - { - if (endpoint.Response is not { } response || response.ResponseType is not { } responseType) - { - return; - } - - if (response.IsEndpointMetadataProvider) - { - codeWriter.WriteLine($"PopulateMetadataForEndpoint<{responseType.ToDisplayString(EmitterConstants.DisplayFormat)}>(methodInfo, options.EndpointBuilder);"); - } - } - private static void EmitCallsToMetadataProvidersForParameters(this Endpoint endpoint, CodeWriter codeWriter) - { - if (endpoint.EmitterContext.HasEndpointParameterMetadataProvider) - { - codeWriter.WriteLine("var parameterInfos = methodInfo.GetParameters();"); - } - - foreach (var parameter in endpoint.Parameters) - { - if (parameter is { Source: EndpointParameterSource.AsParameters, EndpointParameters: { } innerParameters }) - { - foreach (var innerParameter in innerParameters) - { - ProcessParameter(innerParameter, codeWriter); - } - } - else - { - ProcessParameter(parameter, codeWriter); - } - } - - static void ProcessParameter(EndpointParameter parameter, CodeWriter codeWriter) - { - if (parameter.Type is not { } parameterType) - { - return; - } - - if (parameter.IsEndpointParameterMetadataProvider) - { - var resolveParameterInfo = parameter.IsProperty - ? parameter.PropertyAsParameterInfoConstruction - : $"parameterInfos[{parameter.Ordinal}]"; - codeWriter.WriteLine($"var {parameter.SymbolName}_ParameterInfo = {resolveParameterInfo};"); - codeWriter.WriteLine($"PopulateMetadataForParameter<{parameterType.ToDisplayString(EmitterConstants.DisplayFormat)}>({parameter.SymbolName}_ParameterInfo, options.EndpointBuilder);"); - } - - if (parameter.IsEndpointMetadataProvider) - { - codeWriter.WriteLine($"PopulateMetadataForEndpoint<{parameterType.ToDisplayString(EmitterConstants.DisplayFormat)}>(methodInfo, options.EndpointBuilder);"); - } - - } - } - - public static void EmitFormAcceptsMetadata(this Endpoint endpoint, CodeWriter codeWriter) - { - var hasFormFiles = endpoint.Parameters.Any(p => p.IsFormFile); - - if (hasFormFiles) - { - codeWriter.WriteLine("options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(contentTypes: GeneratedMetadataConstants.FormFileContentType));"); - } - else - { - codeWriter.WriteLine("options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(contentTypes: GeneratedMetadataConstants.FormContentType));"); - } - } - - public static void EmitJsonAcceptsMetadata(this Endpoint endpoint, CodeWriter codeWriter) - { - EndpointParameter? explicitBodyParameter = null; - var potentialImplicitBodyParameters = new List(); - - foreach (var parameter in endpoint.Parameters) - { - if (explicitBodyParameter == null && parameter.Source == EndpointParameterSource.JsonBody) - { - explicitBodyParameter = parameter; - break; - } - else if (parameter.Source == EndpointParameterSource.JsonBodyOrService) - { - potentialImplicitBodyParameters.Add(parameter); - } - } - - if (explicitBodyParameter != null) - { - codeWriter.WriteLine($$"""options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(type: typeof({{explicitBodyParameter.Type.ToDisplayString(EmitterConstants.DisplayFormatWithoutNullability)}}), isOptional: {{(explicitBodyParameter.IsOptional ? "true" : "false")}}, contentTypes: GeneratedMetadataConstants.JsonContentType));"""); - } - else if (potentialImplicitBodyParameters.Count > 0) - { - codeWriter.WriteLine("var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices;"); - codeWriter.WriteLine($"var serviceProviderIsService = serviceProvider.GetRequiredService();"); - - codeWriter.WriteLine("var jsonBodyOrServiceTypeTuples = new (bool, Type)[] {"); - codeWriter.Indent++; - foreach (var parameter in potentialImplicitBodyParameters) - { - codeWriter.WriteLine($$"""({{(parameter.IsOptional ? "true" : "false")}}, typeof({{parameter.Type.ToDisplayString(EmitterConstants.DisplayFormatWithoutNullability)}})),"""); - } - codeWriter.Indent--; - codeWriter.WriteLine("};"); - codeWriter.WriteLine("foreach (var (isOptional, type) in jsonBodyOrServiceTypeTuples)"); - codeWriter.StartBlock(); - codeWriter.WriteLine("if (!serviceProviderIsService.IsService(type))"); - codeWriter.StartBlock(); - codeWriter.WriteLine("options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(type: type, isOptional: isOptional, contentTypes: GeneratedMetadataConstants.JsonContentType));"); - codeWriter.WriteLine("break;"); - codeWriter.EndBlock(); - codeWriter.EndBlock(); - } - else - { - codeWriter.WriteLine($"options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(contentTypes: GeneratedMetadataConstants.JsonContentType));"); - } - } - - public static void EmitAcceptsMetadata(this Endpoint endpoint, CodeWriter codeWriter) - { - var hasJsonBody = endpoint.EmitterContext.HasJsonBody || endpoint.EmitterContext.HasJsonBodyOrService; - - if (endpoint.EmitterContext.HasFormBody) - { - endpoint.EmitFormAcceptsMetadata(codeWriter); - } - else if (hasJsonBody) - { - endpoint.EmitJsonAcceptsMetadata(codeWriter); - } - } - - public static void EmitEndpointMetadataPopulation(this Endpoint endpoint, CodeWriter codeWriter) - { - endpoint.EmitAcceptsMetadata(codeWriter); - endpoint.EmitBuiltinResponseTypeMetadata(codeWriter); - endpoint.EmitCallsToMetadataProvidersForParameters(codeWriter); - endpoint.EmitCallToMetadataProviderForResponse(codeWriter); - } - - public static void EmitFilteredInvocation(this Endpoint endpoint, CodeWriter codeWriter) - { - if (endpoint.Response?.HasNoResponse == true) - { - codeWriter.WriteLine(endpoint.Response?.IsAwaitable == true - ? $"await handler({endpoint.EmitFilteredArgumentList()});" - : $"handler({endpoint.EmitFilteredArgumentList()});"); - codeWriter.WriteLine("return ValueTask.FromResult(Results.Empty);"); - } - else if (endpoint.Response?.IsAwaitable == true) - { - codeWriter.WriteLine($"var result = await handler({endpoint.EmitFilteredArgumentList()});"); - codeWriter.WriteLine("return (object?)result;"); - } - else - { - codeWriter.WriteLine($"return ValueTask.FromResult(handler({endpoint.EmitFilteredArgumentList()}));"); - } - } - - public static string EmitFilteredArgumentList(this Endpoint endpoint) - { - if (endpoint.Parameters.Length == 0) - { - return string.Empty; - } - - var sb = new StringBuilder(); - - for (var i = 0; i < endpoint.Parameters.Length; i++) - { - // The null suppression operator on the GetArgument(...) call here is required because we'll occassionally be - // dealing with nullable types here. We could try to do fancy things to branch the logic here depending on - // the nullability, but at the end of the day we are going to call GetArguments(...) - at runtime the nullability - // suppression operator doesn't come into play - so its not worth worrying about. - sb.Append($"ic.GetArgument<{endpoint.Parameters[i].Type.ToDisplayString(EmitterConstants.DisplayFormat)}>({i})!"); - - if (i < endpoint.Parameters.Length - 1) - { - sb.Append(", "); - } - } - - return sb.ToString(); - } - - public static string EmitFilterInvocationContextTypeArgs(this Endpoint endpoint) - { - if (endpoint.Parameters.Length == 0) - { - return string.Empty; - } - - var sb = new StringBuilder(); - - for (var i = 0; i < endpoint.Parameters.Length; i++) - { - sb.Append(endpoint.Parameters[i].Type.ToDisplayString(endpoint.Parameters[i].IsOptional ? NullableFlowState.MaybeNull : NullableFlowState.NotNull, EmitterConstants.DisplayFormat)); - - if (i < endpoint.Parameters.Length - 1) - { - sb.Append(", "); - } - } - - return sb.ToString(); - } -} diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_BindAsync_Snapshot.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_BindAsync_Snapshot.generated.txt index c51031f9eb35..b6cc25e33e2c 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_BindAsync_Snapshot.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_BindAsync_Snapshot.generated.txt @@ -22,14 +22,51 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute + { + public InterceptsLocationAttribute(string filePath, int line, int column) + { + } + } +} + +namespace Microsoft.AspNetCore.Http.Generated +{ + using System; + using System.Collections; + using System.Collections.Generic; + using System.Collections.ObjectModel; + using System.Diagnostics; + using System.Diagnostics.CodeAnalysis; + using System.Globalization; + using System.Linq; + using System.Reflection; + using System.Text.Json; + using System.Text.Json.Serialization.Metadata; + using System.Threading.Tasks; + using System.IO; + using Microsoft.AspNetCore.Routing; + using Microsoft.AspNetCore.Routing.Patterns; + using Microsoft.AspNetCore.Builder; + using Microsoft.AspNetCore.Http; + using Microsoft.AspNetCore.Http.Json; + using Microsoft.AspNetCore.Http.Metadata; + using Microsoft.Extensions.DependencyInjection; + using Microsoft.Extensions.FileProviders; + using Microsoft.Extensions.Logging; + using Microsoft.Extensions.Primitives; + using Microsoft.Extensions.Options; + + using MetadataPopulator = System.Func; + using RequestDelegateFactoryFunc = System.Func; + + 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 }; @@ -37,1728 +74,1674 @@ namespace Microsoft.AspNetCore.Builder private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) - { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); - } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) - { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); - } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) - { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); - } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) - { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); - } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) - { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); - } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) - { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); - } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) - { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); - } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) - { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); - } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) - { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); - } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + global::System.Delegate handler) { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.HttpContext arg0, global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord arg1) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var parameters = del.Method.GetParameters(); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + { + if (ic.HttpContext.Response.StatusCode == 400) + { + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); + }, + options.EndpointBuilder, + handler.Method); + } + + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var httpContext_local = httpContext; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord.BindAsync(httpContext, parameters[1]); + global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord myBindAsyncParam_local; + if ((object?)myBindAsyncParam_temp == null) + { + logOrThrowExceptionHelper.RequiredParameterNotProvided("MyBindAsyncRecord", "myBindAsyncParam", "MyBindAsyncRecord.BindAsync(HttpContext, ParameterInfo)"); + wasParamCheckFailure = true; + myBindAsyncParam_local = default!; + } + else + { + myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord)myBindAsyncParam_temp; + } + + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return; + } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(httpContext_local, myBindAsyncParam_local); + await httpContext.Response.WriteAsync(result); + } + + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var httpContext_local = httpContext; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord.BindAsync(httpContext, parameters[1]); + global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord myBindAsyncParam_local; + if ((object?)myBindAsyncParam_temp == null) + { + logOrThrowExceptionHelper.RequiredParameterNotProvided("MyBindAsyncRecord", "myBindAsyncParam", "MyBindAsyncRecord.BindAsync(HttpContext, ParameterInfo)"); + wasParamCheckFailure = true; + myBindAsyncParam_local = default!; + } + else + { + myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord)myBindAsyncParam_temp; + } + + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, httpContext_local, myBindAsyncParam_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( endpoints, pattern, handler, GetVerb, - filePath, - lineNumber); + populateMetadata, + createRequestDelegate); } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( + +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 26, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_26( this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + global::System.Delegate handler) { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 26)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord? arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var parameters = del.Method.GetParameters(); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + { + if (ic.HttpContext.Response.StatusCode == 400) + { + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } + + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord.BindAsync(httpContext, parameters[0]); + var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord?)myBindAsyncParam_temp; + + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return; + } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(myBindAsyncParam_local); + await httpContext.Response.WriteAsync(result); + } + + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord.BindAsync(httpContext, parameters[0]); + var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord?)myBindAsyncParam_temp; + + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, myBindAsyncParam_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( endpoints, pattern, handler, GetVerb, - filePath, - lineNumber); + populateMetadata, + createRequestDelegate); } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( + +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 27, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_27( this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + global::System.Delegate handler) { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 27)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.HttpContext arg0, global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct arg1) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var parameters = del.Method.GetParameters(); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + { + if (ic.HttpContext.Response.StatusCode == 400) + { + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); + }, + options.EndpointBuilder, + handler.Method); + } + + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var httpContext_local = httpContext; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct.BindAsync(httpContext, parameters[1]); + global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct myBindAsyncParam_local; + if ((object?)myBindAsyncParam_temp == null) + { + logOrThrowExceptionHelper.RequiredParameterNotProvided("MyBindAsyncStruct", "myBindAsyncParam", "MyBindAsyncStruct.BindAsync(HttpContext, ParameterInfo)"); + wasParamCheckFailure = true; + myBindAsyncParam_local = default!; + } + else + { + myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct)myBindAsyncParam_temp; + } + + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return; + } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(httpContext_local, myBindAsyncParam_local); + await httpContext.Response.WriteAsync(result); + } + + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var httpContext_local = httpContext; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct.BindAsync(httpContext, parameters[1]); + global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct myBindAsyncParam_local; + if ((object?)myBindAsyncParam_temp == null) + { + logOrThrowExceptionHelper.RequiredParameterNotProvided("MyBindAsyncStruct", "myBindAsyncParam", "MyBindAsyncStruct.BindAsync(HttpContext, ParameterInfo)"); + wasParamCheckFailure = true; + myBindAsyncParam_local = default!; + } + else + { + myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct)myBindAsyncParam_temp; + } + + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, httpContext_local, myBindAsyncParam_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( endpoints, pattern, handler, GetVerb, - filePath, - lineNumber); + populateMetadata, + createRequestDelegate); } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( + +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 28, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_28( this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + global::System.Delegate handler) { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 28)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct? arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var parameters = del.Method.GetParameters(); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + { + if (ic.HttpContext.Response.StatusCode == 400) + { + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } + + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct.BindAsync(httpContext, parameters[0]); + var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct?)myBindAsyncParam_temp; + + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return; + } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(myBindAsyncParam_local); + await httpContext.Response.WriteAsync(result); + } + + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct.BindAsync(httpContext, parameters[0]); + var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct?)myBindAsyncParam_temp; + + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, myBindAsyncParam_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( endpoints, pattern, handler, GetVerb, - filePath, - lineNumber); + populateMetadata, + createRequestDelegate); } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( + +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 29, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_29( this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + global::System.Delegate handler) { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 29)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.HttpContext arg0, global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct arg1) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var parameters = del.Method.GetParameters(); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + { + if (ic.HttpContext.Response.StatusCode == 400) + { + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); + }, + options.EndpointBuilder, + handler.Method); + } + + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var httpContext_local = httpContext; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct.BindAsync(httpContext, parameters[1]); + global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct myBindAsyncParam_local; + if ((object?)myBindAsyncParam_temp == null) + { + logOrThrowExceptionHelper.RequiredParameterNotProvided("MyNullableBindAsyncStruct", "myBindAsyncParam", "MyNullableBindAsyncStruct.BindAsync(HttpContext, ParameterInfo)"); + wasParamCheckFailure = true; + myBindAsyncParam_local = default!; + } + else + { + myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct)myBindAsyncParam_temp; + } + + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return; + } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(httpContext_local, myBindAsyncParam_local); + await httpContext.Response.WriteAsync(result); + } + + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var httpContext_local = httpContext; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct.BindAsync(httpContext, parameters[1]); + global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct myBindAsyncParam_local; + if ((object?)myBindAsyncParam_temp == null) + { + logOrThrowExceptionHelper.RequiredParameterNotProvided("MyNullableBindAsyncStruct", "myBindAsyncParam", "MyNullableBindAsyncStruct.BindAsync(HttpContext, ParameterInfo)"); + wasParamCheckFailure = true; + myBindAsyncParam_local = default!; + } + else + { + myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct)myBindAsyncParam_temp; + } + + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, httpContext_local, myBindAsyncParam_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( endpoints, pattern, handler, GetVerb, - filePath, - lineNumber); + populateMetadata, + createRequestDelegate); } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( + +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 30, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_30( this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + global::System.Delegate handler) { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 30)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct? arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var parameters = del.Method.GetParameters(); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + { + if (ic.HttpContext.Response.StatusCode == 400) + { + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } + + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct.BindAsync(httpContext, parameters[0]); + var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct?)myBindAsyncParam_temp; + + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return; + } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(myBindAsyncParam_local); + await httpContext.Response.WriteAsync(result); + } + + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct.BindAsync(httpContext, parameters[0]); + var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct?)myBindAsyncParam_temp; + + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, myBindAsyncParam_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( endpoints, pattern, handler, GetVerb, - filePath, - lineNumber); + populateMetadata, + createRequestDelegate); } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( + +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 31, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_31( this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + global::System.Delegate handler) { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 31)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.HttpContext arg0, global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct arg1) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var parameters = del.Method.GetParameters(); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + { + if (ic.HttpContext.Response.StatusCode == 400) + { + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); + }, + options.EndpointBuilder, + handler.Method); + } + + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var httpContext_local = httpContext; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct.BindAsync(httpContext, parameters[1]); + global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct myBindAsyncParam_local; + if ((object?)myBindAsyncParam_temp == null) + { + logOrThrowExceptionHelper.RequiredParameterNotProvided("MyBothBindAsyncStruct", "myBindAsyncParam", "MyBothBindAsyncStruct.BindAsync(HttpContext, ParameterInfo)"); + wasParamCheckFailure = true; + myBindAsyncParam_local = default!; + } + else + { + myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct)myBindAsyncParam_temp; + } + + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return; + } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(httpContext_local, myBindAsyncParam_local); + await httpContext.Response.WriteAsync(result); + } + + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var httpContext_local = httpContext; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct.BindAsync(httpContext, parameters[1]); + global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct myBindAsyncParam_local; + if ((object?)myBindAsyncParam_temp == null) + { + logOrThrowExceptionHelper.RequiredParameterNotProvided("MyBothBindAsyncStruct", "myBindAsyncParam", "MyBothBindAsyncStruct.BindAsync(HttpContext, ParameterInfo)"); + wasParamCheckFailure = true; + myBindAsyncParam_local = default!; + } + else + { + myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct)myBindAsyncParam_temp; + } + + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, httpContext_local, myBindAsyncParam_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( endpoints, pattern, handler, GetVerb, - filePath, - lineNumber); + populateMetadata, + createRequestDelegate); } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( + +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 32, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_32( this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + global::System.Delegate handler) { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 32)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct? arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var parameters = del.Method.GetParameters(); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + { + if (ic.HttpContext.Response.StatusCode == 400) + { + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } + + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct.BindAsync(httpContext, parameters[0]); + var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct?)myBindAsyncParam_temp; + + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return; + } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(myBindAsyncParam_local); + await httpContext.Response.WriteAsync(result); + } + + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct.BindAsync(httpContext, parameters[0]); + var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct?)myBindAsyncParam_temp; + + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, myBindAsyncParam_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( endpoints, pattern, handler, GetVerb, - filePath, - lineNumber); + populateMetadata, + createRequestDelegate); } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( + +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 33, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_33( this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + global::System.Delegate handler) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); - } - - } -} - -namespace Microsoft.AspNetCore.Http.Generated -{ - using System; - using System.Collections; - using System.Collections.Generic; - using System.Collections.ObjectModel; - using System.Diagnostics; - using System.Diagnostics.CodeAnalysis; - using System.Globalization; - using System.Linq; - using System.Reflection; - using System.Text.Json; - using System.Text.Json.Serialization.Metadata; - using System.Threading.Tasks; - using System.IO; - using Microsoft.AspNetCore.Routing; - using Microsoft.AspNetCore.Routing.Patterns; - using Microsoft.AspNetCore.Builder; - using Microsoft.AspNetCore.Http; - using Microsoft.AspNetCore.Http.Json; - using Microsoft.AspNetCore.Http.Metadata; - using Microsoft.Extensions.DependencyInjection; - using Microsoft.Extensions.FileProviders; - using Microsoft.Extensions.Logging; - using Microsoft.Extensions.Primitives; - using Microsoft.Extensions.Options; - - using MetadataPopulator = System.Func; - using RequestDelegateFactoryFunc = System.Func; - - file static class GeneratedRouteBuilderExtensionsCore - { - - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() - { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 33)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.HttpContext arg0, global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord arg1) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var parameters = del.Method.GetParameters(); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); - }, - options.EndpointBuilder, - handler.Method); - } - - async Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var httpContext_local = httpContext; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord.BindAsync(httpContext, parameters[1]); - global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord myBindAsyncParam_local; - if ((object?)myBindAsyncParam_temp == null) - { - logOrThrowExceptionHelper.RequiredParameterNotProvided("MyBindAsyncRecord", "myBindAsyncParam", "MyBindAsyncRecord.BindAsync(HttpContext, ParameterInfo)"); - wasParamCheckFailure = true; - myBindAsyncParam_local = default!; - } - else - { - myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord)myBindAsyncParam_temp; + return ValueTask.FromResult(Results.Empty); } + return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); + }, + options.EndpointBuilder, + handler.Method); + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(httpContext_local, myBindAsyncParam_local); - await httpContext.Response.WriteAsync(result); + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var httpContext_local = httpContext; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord.BindAsync(httpContext); + global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord myBindAsyncParam_local; + if ((object?)myBindAsyncParam_temp == null) + { + logOrThrowExceptionHelper.RequiredParameterNotProvided("MySimpleBindAsyncRecord", "myBindAsyncParam", "MySimpleBindAsyncRecord.BindAsync(HttpContext)"); + wasParamCheckFailure = true; + myBindAsyncParam_local = default!; } - - async Task RequestHandlerFiltered(HttpContext httpContext) + else { - var wasParamCheckFailure = false; - var httpContext_local = httpContext; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord.BindAsync(httpContext, parameters[1]); - global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord myBindAsyncParam_local; - if ((object?)myBindAsyncParam_temp == null) - { - logOrThrowExceptionHelper.RequiredParameterNotProvided("MyBindAsyncRecord", "myBindAsyncParam", "MyBindAsyncRecord.BindAsync(HttpContext, ParameterInfo)"); - wasParamCheckFailure = true; - myBindAsyncParam_local = default!; - } - else - { - myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord)myBindAsyncParam_temp; - } + myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord)myBindAsyncParam_temp; + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, httpContext_local, myBindAsyncParam_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(httpContext_local, myBindAsyncParam_local); + await httpContext.Response.WriteAsync(result); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 26)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 26)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + async Task RequestHandlerFiltered(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var parameters = del.Method.GetParameters(); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + var wasParamCheckFailure = false; + var httpContext_local = httpContext; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord.BindAsync(httpContext); + global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord myBindAsyncParam_local; + if ((object?)myBindAsyncParam_temp == null) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); + logOrThrowExceptionHelper.RequiredParameterNotProvided("MySimpleBindAsyncRecord", "myBindAsyncParam", "MySimpleBindAsyncRecord.BindAsync(HttpContext)"); + wasParamCheckFailure = true; + myBindAsyncParam_local = default!; } - - async Task RequestHandler(HttpContext httpContext) + else { - var wasParamCheckFailure = false; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord.BindAsync(httpContext, parameters[0]); - var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord?)myBindAsyncParam_temp; - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(myBindAsyncParam_local); - await httpContext.Response.WriteAsync(result); + myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord)myBindAsyncParam_temp; } - async Task RequestHandlerFiltered(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord.BindAsync(httpContext, parameters[0]); - var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncRecord?)myBindAsyncParam_temp; - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, myBindAsyncParam_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, httpContext_local, myBindAsyncParam_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 27)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 27)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var parameters = del.Method.GetParameters(); + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - if (options?.EndpointBuilder?.FilterFactories.Count > 0) +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 34, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_34( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 34)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord? arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); - }, - options.EndpointBuilder, - handler.Method); - } - - async Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var httpContext_local = httpContext; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct.BindAsync(httpContext, parameters[1]); - global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct myBindAsyncParam_local; - if ((object?)myBindAsyncParam_temp == null) - { - logOrThrowExceptionHelper.RequiredParameterNotProvided("MyBindAsyncStruct", "myBindAsyncParam", "MyBindAsyncStruct.BindAsync(HttpContext, ParameterInfo)"); - wasParamCheckFailure = true; - myBindAsyncParam_local = default!; - } - else + if (ic.HttpContext.Response.StatusCode == 400) { - myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct)myBindAsyncParam_temp; + return ValueTask.FromResult(Results.Empty); } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(httpContext_local, myBindAsyncParam_local); - await httpContext.Response.WriteAsync(result); - } + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord.BindAsync(httpContext); + var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord?)myBindAsyncParam_temp; - async Task RequestHandlerFiltered(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - var httpContext_local = httpContext; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct.BindAsync(httpContext, parameters[1]); - global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct myBindAsyncParam_local; - if ((object?)myBindAsyncParam_temp == null) - { - logOrThrowExceptionHelper.RequiredParameterNotProvided("MyBindAsyncStruct", "myBindAsyncParam", "MyBindAsyncStruct.BindAsync(HttpContext, ParameterInfo)"); - wasParamCheckFailure = true; - myBindAsyncParam_local = default!; - } - else - { - myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct)myBindAsyncParam_temp; - } - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, httpContext_local, myBindAsyncParam_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + httpContext.Response.StatusCode = 400; + return; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(myBindAsyncParam_local); + await httpContext.Response.WriteAsync(result); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 28)] = ( - (methodInfo, options) => + async Task RequestHandlerFiltered(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 28)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var parameters = del.Method.GetParameters(); + var wasParamCheckFailure = false; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord.BindAsync(httpContext); + var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord?)myBindAsyncParam_temp; - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + if (wasParamCheckFailure) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, myBindAsyncParam_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } - async Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct.BindAsync(httpContext, parameters[0]); - var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct?)myBindAsyncParam_temp; - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(myBindAsyncParam_local); - await httpContext.Response.WriteAsync(result); - } + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - async Task RequestHandlerFiltered(HttpContext httpContext) +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 35, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_35( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 35)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.HttpContext arg0, global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct arg1) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - var wasParamCheckFailure = false; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct.BindAsync(httpContext, parameters[0]); - var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBindAsyncStruct?)myBindAsyncParam_temp; - - if (wasParamCheckFailure) + if (ic.HttpContext.Response.StatusCode == 400) { - httpContext.Response.StatusCode = 400; + return ValueTask.FromResult(Results.Empty); } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, myBindAsyncParam_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); - } + return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); + }, + options.EndpointBuilder, + handler.Method); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 29)] = ( - (methodInfo, options) => + async Task RequestHandler(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 29)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var parameters = del.Method.GetParameters(); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + var wasParamCheckFailure = false; + var httpContext_local = httpContext; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct.BindAsync(httpContext); + global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct myBindAsyncParam_local; + if ((object?)myBindAsyncParam_temp == null) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); - }, - options.EndpointBuilder, - handler.Method); - } - - async Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var httpContext_local = httpContext; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct.BindAsync(httpContext, parameters[1]); - global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct myBindAsyncParam_local; - if ((object?)myBindAsyncParam_temp == null) - { - logOrThrowExceptionHelper.RequiredParameterNotProvided("MyNullableBindAsyncStruct", "myBindAsyncParam", "MyNullableBindAsyncStruct.BindAsync(HttpContext, ParameterInfo)"); - wasParamCheckFailure = true; - myBindAsyncParam_local = default!; - } - else - { - myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct)myBindAsyncParam_temp; - } - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(httpContext_local, myBindAsyncParam_local); - await httpContext.Response.WriteAsync(result); + logOrThrowExceptionHelper.RequiredParameterNotProvided("MySimpleBindAsyncStruct", "myBindAsyncParam", "MySimpleBindAsyncStruct.BindAsync(HttpContext)"); + wasParamCheckFailure = true; + myBindAsyncParam_local = default!; } - - async Task RequestHandlerFiltered(HttpContext httpContext) + else { - var wasParamCheckFailure = false; - var httpContext_local = httpContext; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct.BindAsync(httpContext, parameters[1]); - global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct myBindAsyncParam_local; - if ((object?)myBindAsyncParam_temp == null) - { - logOrThrowExceptionHelper.RequiredParameterNotProvided("MyNullableBindAsyncStruct", "myBindAsyncParam", "MyNullableBindAsyncStruct.BindAsync(HttpContext, ParameterInfo)"); - wasParamCheckFailure = true; - myBindAsyncParam_local = default!; - } - else - { - myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct)myBindAsyncParam_temp; - } - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, httpContext_local, myBindAsyncParam_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct)myBindAsyncParam_temp; } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 30)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 30)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var parameters = del.Method.GetParameters(); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + if (wasParamCheckFailure) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); + httpContext.Response.StatusCode = 400; + return; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(httpContext_local, myBindAsyncParam_local); + await httpContext.Response.WriteAsync(result); + } - async Task RequestHandler(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var httpContext_local = httpContext; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct.BindAsync(httpContext); + global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct myBindAsyncParam_local; + if ((object?)myBindAsyncParam_temp == null) { - var wasParamCheckFailure = false; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct.BindAsync(httpContext, parameters[0]); - var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct?)myBindAsyncParam_temp; - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(myBindAsyncParam_local); - await httpContext.Response.WriteAsync(result); + logOrThrowExceptionHelper.RequiredParameterNotProvided("MySimpleBindAsyncStruct", "myBindAsyncParam", "MySimpleBindAsyncStruct.BindAsync(HttpContext)"); + wasParamCheckFailure = true; + myBindAsyncParam_local = default!; } - - async Task RequestHandlerFiltered(HttpContext httpContext) + else { - var wasParamCheckFailure = false; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct.BindAsync(httpContext, parameters[0]); - var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyNullableBindAsyncStruct?)myBindAsyncParam_temp; - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, myBindAsyncParam_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct)myBindAsyncParam_temp; } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 31)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 31)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var parameters = del.Method.GetParameters(); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + if (wasParamCheckFailure) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); - }, - options.EndpointBuilder, - handler.Method); - } - - async Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var httpContext_local = httpContext; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct.BindAsync(httpContext, parameters[1]); - global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct myBindAsyncParam_local; - if ((object?)myBindAsyncParam_temp == null) - { - logOrThrowExceptionHelper.RequiredParameterNotProvided("MyBothBindAsyncStruct", "myBindAsyncParam", "MyBothBindAsyncStruct.BindAsync(HttpContext, ParameterInfo)"); - wasParamCheckFailure = true; - myBindAsyncParam_local = default!; - } - else - { - myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct)myBindAsyncParam_temp; - } - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(httpContext_local, myBindAsyncParam_local); - await httpContext.Response.WriteAsync(result); + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, httpContext_local, myBindAsyncParam_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } - async Task RequestHandlerFiltered(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var httpContext_local = httpContext; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct.BindAsync(httpContext, parameters[1]); - global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct myBindAsyncParam_local; - if ((object?)myBindAsyncParam_temp == null) - { - logOrThrowExceptionHelper.RequiredParameterNotProvided("MyBothBindAsyncStruct", "myBindAsyncParam", "MyBothBindAsyncStruct.BindAsync(HttpContext, ParameterInfo)"); - wasParamCheckFailure = true; - myBindAsyncParam_local = default!; - } - else - { - myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct)myBindAsyncParam_temp; - } + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - if (wasParamCheckFailure) +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 36, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_36( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 36)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct? arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + { + if (ic.HttpContext.Response.StatusCode == 400) { - httpContext.Response.StatusCode = 400; + return ValueTask.FromResult(Results.Empty); } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, httpContext_local, myBindAsyncParam_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); - } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 32)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 32)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + async Task RequestHandler(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var parameters = del.Method.GetParameters(); + var wasParamCheckFailure = false; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct.BindAsync(httpContext); + var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct?)myBindAsyncParam_temp; - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + if (wasParamCheckFailure) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); + httpContext.Response.StatusCode = 400; + return; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(myBindAsyncParam_local); + await httpContext.Response.WriteAsync(result); + } - async Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct.BindAsync(httpContext, parameters[0]); - var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct?)myBindAsyncParam_temp; - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(myBindAsyncParam_local); - await httpContext.Response.WriteAsync(result); - } + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct.BindAsync(httpContext); + var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct?)myBindAsyncParam_temp; - async Task RequestHandlerFiltered(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct.BindAsync(httpContext, parameters[0]); - var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MyBothBindAsyncStruct?)myBindAsyncParam_temp; - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, myBindAsyncParam_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, myBindAsyncParam_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 33)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 33)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - if (options?.EndpointBuilder?.FilterFactories.Count > 0) +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 37, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_37( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 37)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.HttpContext arg0, global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromImplicitStaticAbstractInterface arg1) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var parameters = del.Method.GetParameters(); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); - }, - options.EndpointBuilder, - handler.Method); - } - - async Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var httpContext_local = httpContext; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord.BindAsync(httpContext); - global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord myBindAsyncParam_local; - if ((object?)myBindAsyncParam_temp == null) - { - logOrThrowExceptionHelper.RequiredParameterNotProvided("MySimpleBindAsyncRecord", "myBindAsyncParam", "MySimpleBindAsyncRecord.BindAsync(HttpContext)"); - wasParamCheckFailure = true; - myBindAsyncParam_local = default!; - } - else - { - myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord)myBindAsyncParam_temp; + return ValueTask.FromResult(Results.Empty); } + return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); + }, + options.EndpointBuilder, + handler.Method); + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(httpContext_local, myBindAsyncParam_local); - await httpContext.Response.WriteAsync(result); + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var httpContext_local = httpContext; + var myBindAsyncParam_temp = await BindAsync(httpContext, parameters[1]); + global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromImplicitStaticAbstractInterface myBindAsyncParam_local; + if ((object?)myBindAsyncParam_temp == null) + { + logOrThrowExceptionHelper.RequiredParameterNotProvided("BindAsyncFromImplicitStaticAbstractInterface", "myBindAsyncParam", "BindAsyncFromImplicitStaticAbstractInterface.BindAsync(HttpContext, ParameterInfo)"); + wasParamCheckFailure = true; + myBindAsyncParam_local = default!; } - - async Task RequestHandlerFiltered(HttpContext httpContext) + else { - var wasParamCheckFailure = false; - var httpContext_local = httpContext; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord.BindAsync(httpContext); - global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord myBindAsyncParam_local; - if ((object?)myBindAsyncParam_temp == null) - { - logOrThrowExceptionHelper.RequiredParameterNotProvided("MySimpleBindAsyncRecord", "myBindAsyncParam", "MySimpleBindAsyncRecord.BindAsync(HttpContext)"); - wasParamCheckFailure = true; - myBindAsyncParam_local = default!; - } - else - { - myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord)myBindAsyncParam_temp; - } + myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromImplicitStaticAbstractInterface)myBindAsyncParam_temp; + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, httpContext_local, myBindAsyncParam_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(httpContext_local, myBindAsyncParam_local); + await httpContext.Response.WriteAsync(result); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 34)] = ( - (methodInfo, options) => + async Task RequestHandlerFiltered(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 34)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + var wasParamCheckFailure = false; + var httpContext_local = httpContext; + var myBindAsyncParam_temp = await BindAsync(httpContext, parameters[1]); + global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromImplicitStaticAbstractInterface myBindAsyncParam_local; + if ((object?)myBindAsyncParam_temp == null) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); + logOrThrowExceptionHelper.RequiredParameterNotProvided("BindAsyncFromImplicitStaticAbstractInterface", "myBindAsyncParam", "BindAsyncFromImplicitStaticAbstractInterface.BindAsync(HttpContext, ParameterInfo)"); + wasParamCheckFailure = true; + myBindAsyncParam_local = default!; } - - async Task RequestHandler(HttpContext httpContext) + else { - var wasParamCheckFailure = false; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord.BindAsync(httpContext); - var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord?)myBindAsyncParam_temp; - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(myBindAsyncParam_local); - await httpContext.Response.WriteAsync(result); + myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromImplicitStaticAbstractInterface)myBindAsyncParam_temp; } - async Task RequestHandlerFiltered(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord.BindAsync(httpContext); - var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncRecord?)myBindAsyncParam_temp; - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, myBindAsyncParam_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, httpContext_local, myBindAsyncParam_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 35)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 35)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - if (options?.EndpointBuilder?.FilterFactories.Count > 0) +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 38, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_38( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 38)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromImplicitStaticAbstractInterface? arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var parameters = del.Method.GetParameters(); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); - }, - options.EndpointBuilder, - handler.Method); - } - - async Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var httpContext_local = httpContext; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct.BindAsync(httpContext); - global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct myBindAsyncParam_local; - if ((object?)myBindAsyncParam_temp == null) - { - logOrThrowExceptionHelper.RequiredParameterNotProvided("MySimpleBindAsyncStruct", "myBindAsyncParam", "MySimpleBindAsyncStruct.BindAsync(HttpContext)"); - wasParamCheckFailure = true; - myBindAsyncParam_local = default!; - } - else + if (ic.HttpContext.Response.StatusCode == 400) { - myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct)myBindAsyncParam_temp; + return ValueTask.FromResult(Results.Empty); } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(httpContext_local, myBindAsyncParam_local); - await httpContext.Response.WriteAsync(result); - } + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var myBindAsyncParam_temp = await BindAsync(httpContext, parameters[0]); + var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromImplicitStaticAbstractInterface?)myBindAsyncParam_temp; - async Task RequestHandlerFiltered(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - var httpContext_local = httpContext; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct.BindAsync(httpContext); - global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct myBindAsyncParam_local; - if ((object?)myBindAsyncParam_temp == null) - { - logOrThrowExceptionHelper.RequiredParameterNotProvided("MySimpleBindAsyncStruct", "myBindAsyncParam", "MySimpleBindAsyncStruct.BindAsync(HttpContext)"); - wasParamCheckFailure = true; - myBindAsyncParam_local = default!; - } - else - { - myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct)myBindAsyncParam_temp; - } - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, httpContext_local, myBindAsyncParam_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + httpContext.Response.StatusCode = 400; + return; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(myBindAsyncParam_local); + await httpContext.Response.WriteAsync(result); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 36)] = ( - (methodInfo, options) => + async Task RequestHandlerFiltered(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 36)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var wasParamCheckFailure = false; + var myBindAsyncParam_temp = await BindAsync(httpContext, parameters[0]); + var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromImplicitStaticAbstractInterface?)myBindAsyncParam_temp; - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + if (wasParamCheckFailure) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, myBindAsyncParam_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } - async Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct.BindAsync(httpContext); - var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct?)myBindAsyncParam_temp; - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(myBindAsyncParam_local); - await httpContext.Response.WriteAsync(result); - } + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - async Task RequestHandlerFiltered(HttpContext httpContext) +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 39, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_39( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 39)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.HttpContext arg0, global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync arg1) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - var wasParamCheckFailure = false; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct.BindAsync(httpContext); - var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.MySimpleBindAsyncStruct?)myBindAsyncParam_temp; - - if (wasParamCheckFailure) + if (ic.HttpContext.Response.StatusCode == 400) { - httpContext.Response.StatusCode = 400; + return ValueTask.FromResult(Results.Empty); } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, myBindAsyncParam_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); - } + return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); + }, + options.EndpointBuilder, + handler.Method); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 37)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 37)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + async Task RequestHandler(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var parameters = del.Method.GetParameters(); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + var wasParamCheckFailure = false; + var httpContext_local = httpContext; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync.BindAsync(httpContext); + global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync myBindAsyncParam_local; + if ((object?)myBindAsyncParam_temp == null) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); - }, - options.EndpointBuilder, - handler.Method); - } - - async Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var httpContext_local = httpContext; - var myBindAsyncParam_temp = await BindAsync(httpContext, parameters[1]); - global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromImplicitStaticAbstractInterface myBindAsyncParam_local; - if ((object?)myBindAsyncParam_temp == null) - { - logOrThrowExceptionHelper.RequiredParameterNotProvided("BindAsyncFromImplicitStaticAbstractInterface", "myBindAsyncParam", "BindAsyncFromImplicitStaticAbstractInterface.BindAsync(HttpContext, ParameterInfo)"); - wasParamCheckFailure = true; - myBindAsyncParam_local = default!; - } - else - { - myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromImplicitStaticAbstractInterface)myBindAsyncParam_temp; - } - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(httpContext_local, myBindAsyncParam_local); - await httpContext.Response.WriteAsync(result); + logOrThrowExceptionHelper.RequiredParameterNotProvided("InheritBindAsync", "myBindAsyncParam", "InheritBindAsync.BindAsync(HttpContext)"); + wasParamCheckFailure = true; + myBindAsyncParam_local = default!; } - - async Task RequestHandlerFiltered(HttpContext httpContext) + else { - var wasParamCheckFailure = false; - var httpContext_local = httpContext; - var myBindAsyncParam_temp = await BindAsync(httpContext, parameters[1]); - global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromImplicitStaticAbstractInterface myBindAsyncParam_local; - if ((object?)myBindAsyncParam_temp == null) - { - logOrThrowExceptionHelper.RequiredParameterNotProvided("BindAsyncFromImplicitStaticAbstractInterface", "myBindAsyncParam", "BindAsyncFromImplicitStaticAbstractInterface.BindAsync(HttpContext, ParameterInfo)"); - wasParamCheckFailure = true; - myBindAsyncParam_local = default!; - } - else - { - myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromImplicitStaticAbstractInterface)myBindAsyncParam_temp; - } + myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync)myBindAsyncParam_temp; + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, httpContext_local, myBindAsyncParam_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(httpContext_local, myBindAsyncParam_local); + await httpContext.Response.WriteAsync(result); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 38)] = ( - (methodInfo, options) => + async Task RequestHandlerFiltered(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 38)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var parameters = del.Method.GetParameters(); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + var wasParamCheckFailure = false; + var httpContext_local = httpContext; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync.BindAsync(httpContext); + global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync myBindAsyncParam_local; + if ((object?)myBindAsyncParam_temp == null) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); + logOrThrowExceptionHelper.RequiredParameterNotProvided("InheritBindAsync", "myBindAsyncParam", "InheritBindAsync.BindAsync(HttpContext)"); + wasParamCheckFailure = true; + myBindAsyncParam_local = default!; } - - async Task RequestHandler(HttpContext httpContext) + else { - var wasParamCheckFailure = false; - var myBindAsyncParam_temp = await BindAsync(httpContext, parameters[0]); - var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromImplicitStaticAbstractInterface?)myBindAsyncParam_temp; - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(myBindAsyncParam_local); - await httpContext.Response.WriteAsync(result); + myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync)myBindAsyncParam_temp; } - async Task RequestHandlerFiltered(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - var myBindAsyncParam_temp = await BindAsync(httpContext, parameters[0]); - var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromImplicitStaticAbstractInterface?)myBindAsyncParam_temp; - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, myBindAsyncParam_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, httpContext_local, myBindAsyncParam_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 39)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 39)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - if (options?.EndpointBuilder?.FilterFactories.Count > 0) +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 40, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_40( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 40)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync? arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); - }, - options.EndpointBuilder, - handler.Method); - } - - async Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var httpContext_local = httpContext; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync.BindAsync(httpContext); - global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync myBindAsyncParam_local; - if ((object?)myBindAsyncParam_temp == null) - { - logOrThrowExceptionHelper.RequiredParameterNotProvided("InheritBindAsync", "myBindAsyncParam", "InheritBindAsync.BindAsync(HttpContext)"); - wasParamCheckFailure = true; - myBindAsyncParam_local = default!; - } - else - { - myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync)myBindAsyncParam_temp; + return ValueTask.FromResult(Results.Empty); } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(httpContext_local, myBindAsyncParam_local); - await httpContext.Response.WriteAsync(result); - } + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync.BindAsync(httpContext); + var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync?)myBindAsyncParam_temp; - async Task RequestHandlerFiltered(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - var httpContext_local = httpContext; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync.BindAsync(httpContext); - global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync myBindAsyncParam_local; - if ((object?)myBindAsyncParam_temp == null) - { - logOrThrowExceptionHelper.RequiredParameterNotProvided("InheritBindAsync", "myBindAsyncParam", "InheritBindAsync.BindAsync(HttpContext)"); - wasParamCheckFailure = true; - myBindAsyncParam_local = default!; - } - else - { - myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync)myBindAsyncParam_temp; - } - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, httpContext_local, myBindAsyncParam_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + httpContext.Response.StatusCode = 400; + return; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(myBindAsyncParam_local); + await httpContext.Response.WriteAsync(result); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 40)] = ( - (methodInfo, options) => + async Task RequestHandlerFiltered(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 40)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var wasParamCheckFailure = false; + var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync.BindAsync(httpContext); + var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync?)myBindAsyncParam_temp; - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + if (wasParamCheckFailure) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, myBindAsyncParam_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } - async Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync.BindAsync(httpContext); - var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync?)myBindAsyncParam_temp; + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - if (wasParamCheckFailure) +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 41, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_41( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 41)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.HttpContext arg0, global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromExplicitStaticAbstractInterface arg1) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var parameters = del.Method.GetParameters(); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + { + if (ic.HttpContext.Response.StatusCode == 400) { - httpContext.Response.StatusCode = 400; - return; + return ValueTask.FromResult(Results.Empty); } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(myBindAsyncParam_local); - await httpContext.Response.WriteAsync(result); - } + return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); + }, + options.EndpointBuilder, + handler.Method); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var httpContext_local = httpContext; + var myBindAsyncParam_temp = await BindAsync(httpContext, parameters[1]); + global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromExplicitStaticAbstractInterface myBindAsyncParam_local; + if ((object?)myBindAsyncParam_temp == null) + { + logOrThrowExceptionHelper.RequiredParameterNotProvided("BindAsyncFromExplicitStaticAbstractInterface", "myBindAsyncParam", "BindAsyncFromExplicitStaticAbstractInterface.BindAsync(HttpContext, ParameterInfo)"); + wasParamCheckFailure = true; + myBindAsyncParam_local = default!; + } + else { - var wasParamCheckFailure = false; - var myBindAsyncParam_temp = await global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync.BindAsync(httpContext); - var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.InheritBindAsync?)myBindAsyncParam_temp; + myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromExplicitStaticAbstractInterface)myBindAsyncParam_temp; + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, myBindAsyncParam_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(httpContext_local, myBindAsyncParam_local); + await httpContext.Response.WriteAsync(result); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 41)] = ( - (methodInfo, options) => + async Task RequestHandlerFiltered(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 41)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var parameters = del.Method.GetParameters(); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + var wasParamCheckFailure = false; + var httpContext_local = httpContext; + var myBindAsyncParam_temp = await BindAsync(httpContext, parameters[1]); + global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromExplicitStaticAbstractInterface myBindAsyncParam_local; + if ((object?)myBindAsyncParam_temp == null) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); - }, - options.EndpointBuilder, - handler.Method); - } - - async Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var httpContext_local = httpContext; - var myBindAsyncParam_temp = await BindAsync(httpContext, parameters[1]); - global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromExplicitStaticAbstractInterface myBindAsyncParam_local; - if ((object?)myBindAsyncParam_temp == null) - { - logOrThrowExceptionHelper.RequiredParameterNotProvided("BindAsyncFromExplicitStaticAbstractInterface", "myBindAsyncParam", "BindAsyncFromExplicitStaticAbstractInterface.BindAsync(HttpContext, ParameterInfo)"); - wasParamCheckFailure = true; - myBindAsyncParam_local = default!; - } - else - { - myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromExplicitStaticAbstractInterface)myBindAsyncParam_temp; - } - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(httpContext_local, myBindAsyncParam_local); - await httpContext.Response.WriteAsync(result); + logOrThrowExceptionHelper.RequiredParameterNotProvided("BindAsyncFromExplicitStaticAbstractInterface", "myBindAsyncParam", "BindAsyncFromExplicitStaticAbstractInterface.BindAsync(HttpContext, ParameterInfo)"); + wasParamCheckFailure = true; + myBindAsyncParam_local = default!; + } + else + { + myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromExplicitStaticAbstractInterface)myBindAsyncParam_temp; } - async Task RequestHandlerFiltered(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - var httpContext_local = httpContext; - var myBindAsyncParam_temp = await BindAsync(httpContext, parameters[1]); - global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromExplicitStaticAbstractInterface myBindAsyncParam_local; - if ((object?)myBindAsyncParam_temp == null) - { - logOrThrowExceptionHelper.RequiredParameterNotProvided("BindAsyncFromExplicitStaticAbstractInterface", "myBindAsyncParam", "BindAsyncFromExplicitStaticAbstractInterface.BindAsync(HttpContext, ParameterInfo)"); - wasParamCheckFailure = true; - myBindAsyncParam_local = default!; - } - else - { - myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromExplicitStaticAbstractInterface)myBindAsyncParam_temp; - } + httpContext.Response.StatusCode = 400; + } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, httpContext_local, myBindAsyncParam_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - if (wasParamCheckFailure) +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 42, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_42( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 42)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromExplicitStaticAbstractInterface? arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var parameters = del.Method.GetParameters(); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + { + if (ic.HttpContext.Response.StatusCode == 400) { - httpContext.Response.StatusCode = 400; + return ValueTask.FromResult(Results.Empty); } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, httpContext_local, myBindAsyncParam_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); - } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 42)] = ( - (methodInfo, options) => + async Task RequestHandler(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 42)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var parameters = del.Method.GetParameters(); + var wasParamCheckFailure = false; + var myBindAsyncParam_temp = await BindAsync(httpContext, parameters[0]); + var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromExplicitStaticAbstractInterface?)myBindAsyncParam_temp; - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + if (wasParamCheckFailure) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); + httpContext.Response.StatusCode = 400; + return; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(myBindAsyncParam_local); + await httpContext.Response.WriteAsync(result); + } - async Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var myBindAsyncParam_temp = await BindAsync(httpContext, parameters[0]); - var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromExplicitStaticAbstractInterface?)myBindAsyncParam_temp; - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(myBindAsyncParam_local); - await httpContext.Response.WriteAsync(result); - } + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var myBindAsyncParam_temp = await BindAsync(httpContext, parameters[0]); + var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromExplicitStaticAbstractInterface?)myBindAsyncParam_temp; - async Task RequestHandlerFiltered(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - var myBindAsyncParam_temp = await BindAsync(httpContext, parameters[0]); - var myBindAsyncParam_local = (global::Microsoft.AspNetCore.Http.Generators.Tests.BindAsyncFromExplicitStaticAbstractInterface?)myBindAsyncParam_temp; - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, myBindAsyncParam_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, myBindAsyncParam_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitBodyParam_ComplexReturn_Snapshot.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitBodyParam_ComplexReturn_Snapshot.generated.txt index d2b44024dfa9..208236a5136b 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitBodyParam_ComplexReturn_Snapshot.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitBodyParam_ComplexReturn_Snapshot.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapPost( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func> handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - PostVerb, - filePath, - lineNumber); } - } } @@ -88,176 +68,210 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapPost_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(type: typeof(global::Microsoft.AspNetCore.Http.Generators.Tests.Todo), isOptional: false, contentTypes: GeneratedMetadataConstants.JsonContentType)); - PopulateMetadataForEndpoint>(methodInfo, options.EndpointBuilder); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(type: typeof(global::Microsoft.AspNetCore.Http.Generators.Tests.Todo), isOptional: false, contentTypes: GeneratedMetadataConstants.JsonContentType)); + PopulateMetadataForEndpoint>(methodInfo, options.EndpointBuilder); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::Microsoft.AspNetCore.Http.HttpResults.Ok (global::Microsoft.AspNetCore.Http.Generators.Tests.Todo arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func>)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } + + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: todo (Type = Microsoft.AspNetCore.Http.Generators.Tests.Todo, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBody) + var todo_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync(httpContext, logOrThrowExceptionHelper, false, "Todo", "todo"); + var todo_local = todo_resolveBodyResult.Item2; + if (!todo_resolveBodyResult.Item1) + { + return; } - async Task RequestHandler(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - // Endpoint Parameter: todo (Type = Microsoft.AspNetCore.Http.Generators.Tests.Todo, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBody) - var todo_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync(httpContext, logOrThrowExceptionHelper, false, "Todo", "todo"); - var todo_local = todo_resolveBodyResult.Item2; - if (!todo_resolveBodyResult.Item1) - { - return; - } + httpContext.Response.StatusCode = 400; + return; + } + var result = handler(todo_local!); + await GeneratedRouteBuilderExtensionsCore.ExecuteAsyncExplicit(result, httpContext); + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - var result = handler(todo_local!); - await GeneratedRouteBuilderExtensionsCore.ExecuteAsyncExplicit(result, httpContext); + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: todo (Type = Microsoft.AspNetCore.Http.Generators.Tests.Todo, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBody) + var todo_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync(httpContext, logOrThrowExceptionHelper, false, "Todo", "todo"); + var todo_local = todo_resolveBodyResult.Item2; + if (!todo_resolveBodyResult.Item1) + { + return; } - async Task RequestHandlerFiltered(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - // Endpoint Parameter: todo (Type = Microsoft.AspNetCore.Http.Generators.Tests.Todo, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBody) - var todo_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync(httpContext, logOrThrowExceptionHelper, false, "Todo", "todo"); - var todo_local = todo_resolveBodyResult.Item2; - if (!todo_resolveBodyResult.Item1) - { - return; - } + httpContext.Response.StatusCode = 400; + } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, todo_local!)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } - if (wasParamCheckFailure) + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + PostVerb, + populateMetadata, + createRequestDelegate); + } + +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 27, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapPost_27( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 27)); + options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(type: typeof(global::Microsoft.AspNetCore.Http.Generators.Tests.Todo), isOptional: true, contentTypes: GeneratedMetadataConstants.JsonContentType)); + PopulateMetadataForEndpoint>(methodInfo, options.EndpointBuilder); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::Microsoft.AspNetCore.Http.HttpResults.Ok (global::Microsoft.AspNetCore.Http.Generators.Tests.Todo? arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + { + if (ic.HttpContext.Response.StatusCode == 400) { - httpContext.Response.StatusCode = 400; + return ValueTask.FromResult(Results.Empty); } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, todo_local!)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); - } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 27)] = ( - (methodInfo, options) => + async Task RequestHandler(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 27)); - options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(type: typeof(global::Microsoft.AspNetCore.Http.Generators.Tests.Todo), isOptional: true, contentTypes: GeneratedMetadataConstants.JsonContentType)); - PopulateMetadataForEndpoint>(methodInfo, options.EndpointBuilder); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func>)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + var wasParamCheckFailure = false; + // Endpoint Parameter: todo (Type = Microsoft.AspNetCore.Http.Generators.Tests.Todo?, IsOptional = True, IsParsable = False, IsArray = False, Source = JsonBody) + var todo_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync(httpContext, logOrThrowExceptionHelper, true, "Todo?", "todo"); + var todo_local = todo_resolveBodyResult.Item2; + if (!todo_resolveBodyResult.Item1) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); + return; } - async Task RequestHandler(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - // Endpoint Parameter: todo (Type = Microsoft.AspNetCore.Http.Generators.Tests.Todo?, IsOptional = True, IsParsable = False, IsArray = False, Source = JsonBody) - var todo_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync(httpContext, logOrThrowExceptionHelper, true, "Todo?", "todo"); - var todo_local = todo_resolveBodyResult.Item2; - if (!todo_resolveBodyResult.Item1) - { - return; - } - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - var result = handler(todo_local); - await GeneratedRouteBuilderExtensionsCore.ExecuteAsyncExplicit(result, httpContext); + httpContext.Response.StatusCode = 400; + return; } + var result = handler(todo_local); + await GeneratedRouteBuilderExtensionsCore.ExecuteAsyncExplicit(result, httpContext); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: todo (Type = Microsoft.AspNetCore.Http.Generators.Tests.Todo?, IsOptional = True, IsParsable = False, IsArray = False, Source = JsonBody) + var todo_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync(httpContext, logOrThrowExceptionHelper, true, "Todo?", "todo"); + var todo_local = todo_resolveBodyResult.Item2; + if (!todo_resolveBodyResult.Item1) { - var wasParamCheckFailure = false; - // Endpoint Parameter: todo (Type = Microsoft.AspNetCore.Http.Generators.Tests.Todo?, IsOptional = True, IsParsable = False, IsArray = False, Source = JsonBody) - var todo_resolveBodyResult = await GeneratedRouteBuilderExtensionsCore.TryResolveBodyAsync(httpContext, logOrThrowExceptionHelper, true, "Todo?", "todo"); - var todo_local = todo_resolveBodyResult.Item2; - if (!todo_resolveBodyResult.Item1) - { - return; - } + return; + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, todo_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, todo_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + PostVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitHeader_ComplexTypeArrayParam.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitHeader_ComplexTypeArrayParam.generated.txt index 50752ba6ef3d..756dc083899f 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitHeader_ComplexTypeArrayParam.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitHeader_ComplexTypeArrayParam.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,122 +68,142 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.Int32 (global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[] arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; + var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; - var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[], IsOptional = False, IsParsable = True, IsArray = True, Source = Header) + var p_raw = httpContext.Request.Headers["p"]; + var p_temp = p_raw.ToArray(); + global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[] p_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[p_temp.Length]; + for (var i = 0; i < p_temp.Length; i++) { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[], IsOptional = False, IsParsable = True, IsArray = True, Source = Header) - var p_raw = httpContext.Request.Headers["p"]; - var p_temp = p_raw.ToArray(); - global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[] p_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[p_temp.Length]; - for (var i = 0; i < p_temp.Length; i++) + var element = p_temp[i]; + if (!GeneratedRouteBuilderExtensionsCore.TryParseExplicit(element!, CultureInfo.InvariantCulture, out var parsed_element)) { - var element = p_temp[i]; - if (!GeneratedRouteBuilderExtensionsCore.TryParseExplicit(element!, CultureInfo.InvariantCulture, out var parsed_element)) + if (!string.IsNullOrEmpty(element)) { - if (!string.IsNullOrEmpty(element)) - { - logOrThrowExceptionHelper.ParameterBindingFailed("ParsableTodo[]", "p", element); - wasParamCheckFailure = true; - } + logOrThrowExceptionHelper.ParameterBindingFailed("ParsableTodo[]", "p", element); + wasParamCheckFailure = true; } - p_local[i] = parsed_element!; } + p_local[i] = parsed_element!; + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "application/json"; - var result = handler(p_local); - return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "application/json"; + var result = handler(p_local); + return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[], IsOptional = False, IsParsable = True, IsArray = True, Source = Header) + var p_raw = httpContext.Request.Headers["p"]; + var p_temp = p_raw.ToArray(); + global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[] p_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[p_temp.Length]; + for (var i = 0; i < p_temp.Length; i++) { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[], IsOptional = False, IsParsable = True, IsArray = True, Source = Header) - var p_raw = httpContext.Request.Headers["p"]; - var p_temp = p_raw.ToArray(); - global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[] p_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[p_temp.Length]; - for (var i = 0; i < p_temp.Length; i++) + var element = p_temp[i]; + if (!GeneratedRouteBuilderExtensionsCore.TryParseExplicit(element!, CultureInfo.InvariantCulture, out var parsed_element)) { - var element = p_temp[i]; - if (!GeneratedRouteBuilderExtensionsCore.TryParseExplicit(element!, CultureInfo.InvariantCulture, out var parsed_element)) + if (!string.IsNullOrEmpty(element)) { - if (!string.IsNullOrEmpty(element)) - { - logOrThrowExceptionHelper.ParameterBindingFailed("ParsableTodo[]", "p", element); - wasParamCheckFailure = true; - } + logOrThrowExceptionHelper.ParameterBindingFailed("ParsableTodo[]", "p", element); + wasParamCheckFailure = true; } - p_local[i] = parsed_element!; } + p_local[i] = parsed_element!; + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitHeader_NullableStringArrayParam.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitHeader_NullableStringArrayParam.generated.txt index feddc45e748b..836c6ae18a44 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitHeader_NullableStringArrayParam.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitHeader_NullableStringArrayParam.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,96 +68,116 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.Int32 (global::System.String?[] arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; + var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; - var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string?[], IsOptional = False, IsParsable = False, IsArray = True, Source = Header) - var p_raw = httpContext.Request.Headers["p"]; - var p_temp = p_raw.ToArray(); - string[] p_local = p_temp!; + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string?[], IsOptional = False, IsParsable = False, IsArray = True, Source = Header) + var p_raw = httpContext.Request.Headers["p"]; + var p_temp = p_raw.ToArray(); + string[] p_local = p_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "application/json"; - var result = handler(p_local); - return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "application/json"; + var result = handler(p_local); + return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + } - async Task RequestHandlerFiltered(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string?[], IsOptional = False, IsParsable = False, IsArray = True, Source = Header) - var p_raw = httpContext.Request.Headers["p"]; - var p_temp = p_raw.ToArray(); - string[] p_local = p_temp!; + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string?[], IsOptional = False, IsParsable = False, IsArray = True, Source = Header) + var p_raw = httpContext.Request.Headers["p"]; + var p_temp = p_raw.ToArray(); + string[] p_local = p_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitHeader_StringArrayParam.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitHeader_StringArrayParam.generated.txt index 7d7a0d42d97f..815161685950 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitHeader_StringArrayParam.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitHeader_StringArrayParam.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,96 +68,116 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.Int32 (global::System.String[] arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; + var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; - var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string[], IsOptional = False, IsParsable = False, IsArray = True, Source = Header) - var p_raw = httpContext.Request.Headers["p"]; - var p_temp = p_raw.ToArray(); - string[] p_local = p_temp!; + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string[], IsOptional = False, IsParsable = False, IsArray = True, Source = Header) + var p_raw = httpContext.Request.Headers["p"]; + var p_temp = p_raw.ToArray(); + string[] p_local = p_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "application/json"; - var result = handler(p_local); - return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "application/json"; + var result = handler(p_local); + return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + } - async Task RequestHandlerFiltered(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string[], IsOptional = False, IsParsable = False, IsArray = True, Source = Header) - var p_raw = httpContext.Request.Headers["p"]; - var p_temp = p_raw.ToArray(); - string[] p_local = p_temp!; + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string[], IsOptional = False, IsParsable = False, IsArray = True, Source = Header) + var p_raw = httpContext.Request.Headers["p"]; + var p_temp = p_raw.ToArray(); + string[] p_local = p_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitQuery_ComplexTypeArrayParam.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitQuery_ComplexTypeArrayParam.generated.txt index c8339e999c3a..0c44cccc0ccd 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitQuery_ComplexTypeArrayParam.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitQuery_ComplexTypeArrayParam.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,122 +68,142 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.Int32 (global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[] arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; + var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; - var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[], IsOptional = False, IsParsable = True, IsArray = True, Source = Query) + var p_raw = httpContext.Request.Query["p"]; + var p_temp = p_raw.ToArray(); + global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[] p_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[p_temp.Length]; + for (var i = 0; i < p_temp.Length; i++) { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[], IsOptional = False, IsParsable = True, IsArray = True, Source = Query) - var p_raw = httpContext.Request.Query["p"]; - var p_temp = p_raw.ToArray(); - global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[] p_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[p_temp.Length]; - for (var i = 0; i < p_temp.Length; i++) + var element = p_temp[i]; + if (!GeneratedRouteBuilderExtensionsCore.TryParseExplicit(element!, CultureInfo.InvariantCulture, out var parsed_element)) { - var element = p_temp[i]; - if (!GeneratedRouteBuilderExtensionsCore.TryParseExplicit(element!, CultureInfo.InvariantCulture, out var parsed_element)) + if (!string.IsNullOrEmpty(element)) { - if (!string.IsNullOrEmpty(element)) - { - logOrThrowExceptionHelper.ParameterBindingFailed("ParsableTodo[]", "p", element); - wasParamCheckFailure = true; - } + logOrThrowExceptionHelper.ParameterBindingFailed("ParsableTodo[]", "p", element); + wasParamCheckFailure = true; } - p_local[i] = parsed_element!; } + p_local[i] = parsed_element!; + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "application/json"; - var result = handler(p_local); - return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "application/json"; + var result = handler(p_local); + return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[], IsOptional = False, IsParsable = True, IsArray = True, Source = Query) + var p_raw = httpContext.Request.Query["p"]; + var p_temp = p_raw.ToArray(); + global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[] p_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[p_temp.Length]; + for (var i = 0; i < p_temp.Length; i++) { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[], IsOptional = False, IsParsable = True, IsArray = True, Source = Query) - var p_raw = httpContext.Request.Query["p"]; - var p_temp = p_raw.ToArray(); - global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[] p_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[p_temp.Length]; - for (var i = 0; i < p_temp.Length; i++) + var element = p_temp[i]; + if (!GeneratedRouteBuilderExtensionsCore.TryParseExplicit(element!, CultureInfo.InvariantCulture, out var parsed_element)) { - var element = p_temp[i]; - if (!GeneratedRouteBuilderExtensionsCore.TryParseExplicit(element!, CultureInfo.InvariantCulture, out var parsed_element)) + if (!string.IsNullOrEmpty(element)) { - if (!string.IsNullOrEmpty(element)) - { - logOrThrowExceptionHelper.ParameterBindingFailed("ParsableTodo[]", "p", element); - wasParamCheckFailure = true; - } + logOrThrowExceptionHelper.ParameterBindingFailed("ParsableTodo[]", "p", element); + wasParamCheckFailure = true; } - p_local[i] = parsed_element!; } + p_local[i] = parsed_element!; + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitQuery_NullableStringArrayParam.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitQuery_NullableStringArrayParam.generated.txt index d4286778fe3b..16bbeced43c2 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitQuery_NullableStringArrayParam.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitQuery_NullableStringArrayParam.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,95 +68,115 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.Int32 (global::System.String?[] arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; + var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; - var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string?[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) - var p_raw = httpContext.Request.Query["p"]; - var p_temp = p_raw.ToArray(); - string[] p_local = p_temp!; + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string?[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) + var p_raw = httpContext.Request.Query["p"]; + var p_temp = p_raw.ToArray(); + string[] p_local = p_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "application/json"; - var result = handler(p_local); - return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "application/json"; + var result = handler(p_local); + return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + } - async Task RequestHandlerFiltered(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string?[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) - var p_raw = httpContext.Request.Query["p"]; - var p_temp = p_raw.ToArray(); - string[] p_local = p_temp!; + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string?[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) + var p_raw = httpContext.Request.Query["p"]; + var p_temp = p_raw.ToArray(); + string[] p_local = p_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitQuery_StringArrayParam.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitQuery_StringArrayParam.generated.txt index 7965ed87b87b..9b3838996817 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitQuery_StringArrayParam.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitQuery_StringArrayParam.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,95 +68,115 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.Int32 (global::System.String[] arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; + var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; - var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) - var p_raw = httpContext.Request.Query["p"]; - var p_temp = p_raw.ToArray(); - string[] p_local = p_temp!; + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) + var p_raw = httpContext.Request.Query["p"]; + var p_temp = p_raw.ToArray(); + string[] p_local = p_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "application/json"; - var result = handler(p_local); - return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "application/json"; + var result = handler(p_local); + return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + } - async Task RequestHandlerFiltered(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) - var p_raw = httpContext.Request.Query["p"]; - var p_temp = p_raw.ToArray(); - string[] p_local = p_temp!; + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) + var p_raw = httpContext.Request.Query["p"]; + var p_temp = p_raw.ToArray(); + string[] p_local = p_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitServiceParam_SimpleReturn_Snapshot.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitServiceParam_SimpleReturn_Snapshot.generated.txt index 5c9abf552f9c..e69a9a58eae6 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitServiceParam_SimpleReturn_Snapshot.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitServiceParam_SimpleReturn_Snapshot.generated.txt @@ -22,67 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) - { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); - } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func, global::System.String> handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); - } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func, global::System.String> handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) - { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -118,226 +68,274 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.Generators.Tests.TestService arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); - } - - Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: svc (Type = Microsoft.AspNetCore.Http.Generators.Tests.TestService, IsOptional = False, IsParsable = False, IsArray = False, Source = Service) - var svc_local = httpContext.RequestServices.GetRequiredService(); - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; + return ValueTask.FromResult(Results.Empty); } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(svc_local); - return httpContext.Response.WriteAsync(result); - } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - async Task RequestHandlerFiltered(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: svc (Type = Microsoft.AspNetCore.Http.Generators.Tests.TestService, IsOptional = False, IsParsable = False, IsArray = False, Source = Service) - var svc_local = httpContext.RequestServices.GetRequiredService(); + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: svc (Type = Microsoft.AspNetCore.Http.Generators.Tests.TestService, IsOptional = False, IsParsable = False, IsArray = False, Source = Service) + var svc_local = httpContext.RequestServices.GetRequiredService(); - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, svc_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(svc_local); + return httpContext.Response.WriteAsync(result); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 26)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 26)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + async Task RequestHandlerFiltered(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func, global::System.String>)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + var wasParamCheckFailure = false; + // Endpoint Parameter: svc (Type = Microsoft.AspNetCore.Http.Generators.Tests.TestService, IsOptional = False, IsParsable = False, IsArray = False, Source = Service) + var svc_local = httpContext.RequestServices.GetRequiredService(); + + if (wasParamCheckFailure) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument>(0)!)); - }, - options.EndpointBuilder, - handler.Method); + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, svc_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } - Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: svc (Type = System.Collections.Generic.IEnumerable, IsOptional = False, IsParsable = False, IsArray = False, Source = Service) - var svc_local = httpContext.RequestServices.GetRequiredService>(); + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - if (wasParamCheckFailure) +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 26, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_26( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 26)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::System.Collections.Generic.IEnumerable arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + { + if (ic.HttpContext.Response.StatusCode == 400) { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; + return ValueTask.FromResult(Results.Empty); } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(svc_local); - return httpContext.Response.WriteAsync(result); - } + return ValueTask.FromResult(handler(ic.GetArgument>(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - async Task RequestHandlerFiltered(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: svc (Type = System.Collections.Generic.IEnumerable, IsOptional = False, IsParsable = False, IsArray = False, Source = Service) - var svc_local = httpContext.RequestServices.GetRequiredService>(); + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: svc (Type = System.Collections.Generic.IEnumerable, IsOptional = False, IsParsable = False, IsArray = False, Source = Service) + var svc_local = httpContext.RequestServices.GetRequiredService>(); - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create>(httpContext, svc_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(svc_local); + return httpContext.Response.WriteAsync(result); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 27)] = ( - (methodInfo, options) => + async Task RequestHandlerFiltered(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 27)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func, global::System.String>)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + var wasParamCheckFailure = false; + // Endpoint Parameter: svc (Type = System.Collections.Generic.IEnumerable, IsOptional = False, IsParsable = False, IsArray = False, Source = Service) + var svc_local = httpContext.RequestServices.GetRequiredService>(); + + if (wasParamCheckFailure) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument>(1)!)); - }, - options.EndpointBuilder, - handler.Method); + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create>(httpContext, svc_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } - Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: svc (Type = Microsoft.AspNetCore.Http.Generators.Tests.TestService?, IsOptional = True, IsParsable = False, IsArray = False, Source = Service) - var svc_local = httpContext.RequestServices.GetService();; - // Endpoint Parameter: svcs (Type = System.Collections.Generic.IEnumerable, IsOptional = False, IsParsable = False, IsArray = False, Source = Service) - var svcs_local = httpContext.RequestServices.GetRequiredService>(); + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - if (wasParamCheckFailure) +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 27, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_27( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 27)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.Generators.Tests.TestService? arg0, global::System.Collections.Generic.IEnumerable arg1) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + { + if (ic.HttpContext.Response.StatusCode == 400) { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; + return ValueTask.FromResult(Results.Empty); } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(svc_local, svcs_local); - return httpContext.Response.WriteAsync(result); - } + return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument>(1)!)); + }, + options.EndpointBuilder, + handler.Method); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: svc (Type = Microsoft.AspNetCore.Http.Generators.Tests.TestService?, IsOptional = True, IsParsable = False, IsArray = False, Source = Service) + var svc_local = httpContext.RequestServices.GetService();; + // Endpoint Parameter: svcs (Type = System.Collections.Generic.IEnumerable, IsOptional = False, IsParsable = False, IsArray = False, Source = Service) + var svcs_local = httpContext.RequestServices.GetRequiredService>(); + + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - // Endpoint Parameter: svc (Type = Microsoft.AspNetCore.Http.Generators.Tests.TestService?, IsOptional = True, IsParsable = False, IsArray = False, Source = Service) - var svc_local = httpContext.RequestServices.GetService();; - // Endpoint Parameter: svcs (Type = System.Collections.Generic.IEnumerable, IsOptional = False, IsParsable = False, IsArray = False, Source = Service) - var svcs_local = httpContext.RequestServices.GetRequiredService>(); + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; + } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(svc_local, svcs_local); + return httpContext.Response.WriteAsync(result); + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create>(httpContext, svc_local, svcs_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: svc (Type = Microsoft.AspNetCore.Http.Generators.Tests.TestService?, IsOptional = True, IsParsable = False, IsArray = False, Source = Service) + var svc_local = httpContext.RequestServices.GetService();; + // Endpoint Parameter: svcs (Type = System.Collections.Generic.IEnumerable, IsOptional = False, IsParsable = False, IsArray = False, Source = Service) + var svcs_local = httpContext.RequestServices.GetRequiredService>(); + + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create>(httpContext, svc_local, svcs_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitSource_SimpleReturn_Snapshot.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitSource_SimpleReturn_Snapshot.generated.txt index 090e087af40c..01c58aa4eb74 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitSource_SimpleReturn_Snapshot.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ExplicitSource_SimpleReturn_Snapshot.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,434 +68,510 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::System.String arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } + + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: queryValue (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Query) + var queryValue_raw = httpContext.Request.Query["queryValue"]; + if (StringValues.IsNullOrEmpty(queryValue_raw)) + { + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "queryValue", "query string"); } + var queryValue_temp = (string?)queryValue_raw; + string queryValue_local = queryValue_temp!; - Task RequestHandler(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - // Endpoint Parameter: queryValue (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Query) - var queryValue_raw = httpContext.Request.Query["queryValue"]; - if (StringValues.IsNullOrEmpty(queryValue_raw)) - { - wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "queryValue", "query string"); - } - var queryValue_temp = (string?)queryValue_raw; - string queryValue_local = queryValue_temp!; + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; + } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(queryValue_local); + return httpContext.Response.WriteAsync(result); + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(queryValue_local); - return httpContext.Response.WriteAsync(result); + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: queryValue (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Query) + var queryValue_raw = httpContext.Request.Query["queryValue"]; + if (StringValues.IsNullOrEmpty(queryValue_raw)) + { + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "queryValue", "query string"); } + var queryValue_temp = (string?)queryValue_raw; + string queryValue_local = queryValue_temp!; - async Task RequestHandlerFiltered(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - // Endpoint Parameter: queryValue (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Query) - var queryValue_raw = httpContext.Request.Query["queryValue"]; - if (StringValues.IsNullOrEmpty(queryValue_raw)) - { - wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "queryValue", "query string"); - } - var queryValue_temp = (string?)queryValue_raw; - string queryValue_local = queryValue_temp!; + httpContext.Response.StatusCode = 400; + } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, queryValue_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } - if (wasParamCheckFailure) + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } + +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 26, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_26( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 26)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::System.String arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + { + if (ic.HttpContext.Response.StatusCode == 400) { - httpContext.Response.StatusCode = 400; + return ValueTask.FromResult(Results.Empty); } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, queryValue_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); - } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 26)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 26)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + Task RequestHandler(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + var wasParamCheckFailure = false; + // Endpoint Parameter: headerValue (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Header) + var headerValue_raw = httpContext.Request.Headers["headerValue"]; + if (StringValues.IsNullOrEmpty(headerValue_raw)) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "headerValue", "header"); } + var headerValue_temp = (string?)headerValue_raw; + string headerValue_local = headerValue_temp!; - Task RequestHandler(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - // Endpoint Parameter: headerValue (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Header) - var headerValue_raw = httpContext.Request.Headers["headerValue"]; - if (StringValues.IsNullOrEmpty(headerValue_raw)) - { - wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "headerValue", "header"); - } - var headerValue_temp = (string?)headerValue_raw; - string headerValue_local = headerValue_temp!; + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; + } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(headerValue_local); + return httpContext.Response.WriteAsync(result); + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(headerValue_local); - return httpContext.Response.WriteAsync(result); + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: headerValue (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Header) + var headerValue_raw = httpContext.Request.Headers["headerValue"]; + if (StringValues.IsNullOrEmpty(headerValue_raw)) + { + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "headerValue", "header"); } + var headerValue_temp = (string?)headerValue_raw; + string headerValue_local = headerValue_temp!; - async Task RequestHandlerFiltered(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - // Endpoint Parameter: headerValue (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Header) - var headerValue_raw = httpContext.Request.Headers["headerValue"]; - if (StringValues.IsNullOrEmpty(headerValue_raw)) - { - wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "headerValue", "header"); - } - var headerValue_temp = (string?)headerValue_raw; - string headerValue_local = headerValue_temp!; + httpContext.Response.StatusCode = 400; + } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, headerValue_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - if (wasParamCheckFailure) +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 27, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_27( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 27)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::System.String arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + { + if (ic.HttpContext.Response.StatusCode == 400) { - httpContext.Response.StatusCode = 400; + return ValueTask.FromResult(Results.Empty); } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, headerValue_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); - } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 27)] = ( - (methodInfo, options) => + Task RequestHandler(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 27)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + var wasParamCheckFailure = false; + // Endpoint Parameter: routeValue (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Route) + if (options?.RouteParameterNames?.Contains("routeValue", StringComparer.OrdinalIgnoreCase) != true) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); + throw new InvalidOperationException($"'routeValue' is not a route parameter."); } + var routeValue_raw = (string?)httpContext.Request.RouteValues["routeValue"]; + if (routeValue_raw == null) + { + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "routeValue", "route"); + } + var routeValue_temp = (string?)routeValue_raw; + string routeValue_local = routeValue_temp!; - Task RequestHandler(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - // Endpoint Parameter: routeValue (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Route) - if (options?.RouteParameterNames?.Contains("routeValue", StringComparer.OrdinalIgnoreCase) != true) - { - throw new InvalidOperationException($"'routeValue' is not a route parameter."); - } - var routeValue_raw = (string?)httpContext.Request.RouteValues["routeValue"]; - if (routeValue_raw == null) - { - wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "routeValue", "route"); - } - var routeValue_temp = (string?)routeValue_raw; - string routeValue_local = routeValue_temp!; + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; + } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(routeValue_local!); + return httpContext.Response.WriteAsync(result); + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(routeValue_local!); - return httpContext.Response.WriteAsync(result); + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: routeValue (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Route) + if (options?.RouteParameterNames?.Contains("routeValue", StringComparer.OrdinalIgnoreCase) != true) + { + throw new InvalidOperationException($"'routeValue' is not a route parameter."); } + var routeValue_raw = (string?)httpContext.Request.RouteValues["routeValue"]; + if (routeValue_raw == null) + { + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "routeValue", "route"); + } + var routeValue_temp = (string?)routeValue_raw; + string routeValue_local = routeValue_temp!; - async Task RequestHandlerFiltered(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - // Endpoint Parameter: routeValue (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Route) - if (options?.RouteParameterNames?.Contains("routeValue", StringComparer.OrdinalIgnoreCase) != true) - { - throw new InvalidOperationException($"'routeValue' is not a route parameter."); - } - var routeValue_raw = (string?)httpContext.Request.RouteValues["routeValue"]; - if (routeValue_raw == null) - { - wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "routeValue", "route"); - } - var routeValue_temp = (string?)routeValue_raw; - string routeValue_local = routeValue_temp!; + httpContext.Response.StatusCode = 400; + } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, routeValue_local!)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } - if (wasParamCheckFailure) + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } + +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 28, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_28( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 28)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::System.String arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var value_RouteOrQueryResolver = GeneratedRouteBuilderExtensionsCore.ResolveFromRouteOrQuery("value", options?.RouteParameterNames); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + { + if (ic.HttpContext.Response.StatusCode == 400) { - httpContext.Response.StatusCode = 400; + return ValueTask.FromResult(Results.Empty); } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, routeValue_local!)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); - } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 28)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 28)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + Task RequestHandler(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var value_RouteOrQueryResolver = GeneratedRouteBuilderExtensionsCore.ResolveFromRouteOrQuery("value", options?.RouteParameterNames); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + var wasParamCheckFailure = false; + // Endpoint Parameter: value (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = RouteOrQuery) + var value_raw = value_RouteOrQueryResolver(httpContext); + if (value_raw is StringValues { Count: 0 }) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "value", "route or query string"); } + var value_temp = (string?)value_raw; + string value_local = value_temp!; - Task RequestHandler(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - // Endpoint Parameter: value (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = RouteOrQuery) - var value_raw = value_RouteOrQueryResolver(httpContext); - if (value_raw is StringValues { Count: 0 }) - { - wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "value", "route or query string"); - } - var value_temp = (string?)value_raw; - string value_local = value_temp!; + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; + } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(value_local!); + return httpContext.Response.WriteAsync(result); + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(value_local!); - return httpContext.Response.WriteAsync(result); + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: value (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = RouteOrQuery) + var value_raw = value_RouteOrQueryResolver(httpContext); + if (value_raw is StringValues { Count: 0 }) + { + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "value", "route or query string"); } + var value_temp = (string?)value_raw; + string value_local = value_temp!; - async Task RequestHandlerFiltered(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - // Endpoint Parameter: value (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = RouteOrQuery) - var value_raw = value_RouteOrQueryResolver(httpContext); - if (value_raw is StringValues { Count: 0 }) - { - wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "value", "route or query string"); - } - var value_temp = (string?)value_raw; - string value_local = value_temp!; + httpContext.Response.StatusCode = 400; + } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, value_local!)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } - if (wasParamCheckFailure) + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } + +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 29, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_29( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 29)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::System.String arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var value_RouteOrQueryResolver = GeneratedRouteBuilderExtensionsCore.ResolveFromRouteOrQuery("value", options?.RouteParameterNames); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + { + if (ic.HttpContext.Response.StatusCode == 400) { - httpContext.Response.StatusCode = 400; + return ValueTask.FromResult(Results.Empty); } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, value_local!)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); - } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 29)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 29)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + Task RequestHandler(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var value_RouteOrQueryResolver = GeneratedRouteBuilderExtensionsCore.ResolveFromRouteOrQuery("value", options?.RouteParameterNames); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + var wasParamCheckFailure = false; + // Endpoint Parameter: value (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = RouteOrQuery) + var value_raw = value_RouteOrQueryResolver(httpContext); + if (value_raw is StringValues { Count: 0 }) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "value", "route or query string"); } + var value_temp = (string?)value_raw; + string value_local = value_temp!; - Task RequestHandler(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - // Endpoint Parameter: value (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = RouteOrQuery) - var value_raw = value_RouteOrQueryResolver(httpContext); - if (value_raw is StringValues { Count: 0 }) - { - wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "value", "route or query string"); - } - var value_temp = (string?)value_raw; - string value_local = value_temp!; - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(value_local!); - return httpContext.Response.WriteAsync(result); + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(value_local!); + return httpContext.Response.WriteAsync(result); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: value (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = RouteOrQuery) + var value_raw = value_RouteOrQueryResolver(httpContext); + if (value_raw is StringValues { Count: 0 }) { - var wasParamCheckFailure = false; - // Endpoint Parameter: value (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = RouteOrQuery) - var value_raw = value_RouteOrQueryResolver(httpContext); - if (value_raw is StringValues { Count: 0 }) - { - wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "value", "route or query string"); - } - var value_temp = (string?)value_raw; - string value_local = value_temp!; + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "value", "route or query string"); + } + var value_temp = (string?)value_raw; + string value_local = value_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, value_local!)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, value_local!)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ImplicitQuery_ComplexTypeArrayParam.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ImplicitQuery_ComplexTypeArrayParam.generated.txt index 769e5c359936..cbb9748c9c47 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ImplicitQuery_ComplexTypeArrayParam.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ImplicitQuery_ComplexTypeArrayParam.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,123 +68,143 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.Int32 (global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[] arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var p_RouteOrQueryResolver = GeneratedRouteBuilderExtensionsCore.ResolveFromRouteOrQuery("p", options?.RouteParameterNames); + var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; + var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var p_RouteOrQueryResolver = GeneratedRouteBuilderExtensionsCore.ResolveFromRouteOrQuery("p", options?.RouteParameterNames); - var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; - var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[], IsOptional = False, IsParsable = True, IsArray = True, Source = RouteOrQuery) + var p_raw = p_RouteOrQueryResolver(httpContext); + var p_temp = p_raw.ToArray(); + global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[] p_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[p_temp.Length]; + for (var i = 0; i < p_temp.Length; i++) { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[], IsOptional = False, IsParsable = True, IsArray = True, Source = RouteOrQuery) - var p_raw = p_RouteOrQueryResolver(httpContext); - var p_temp = p_raw.ToArray(); - global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[] p_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[p_temp.Length]; - for (var i = 0; i < p_temp.Length; i++) + var element = p_temp[i]; + if (!GeneratedRouteBuilderExtensionsCore.TryParseExplicit(element!, CultureInfo.InvariantCulture, out var parsed_element)) { - var element = p_temp[i]; - if (!GeneratedRouteBuilderExtensionsCore.TryParseExplicit(element!, CultureInfo.InvariantCulture, out var parsed_element)) + if (!string.IsNullOrEmpty(element)) { - if (!string.IsNullOrEmpty(element)) - { - logOrThrowExceptionHelper.ParameterBindingFailed("ParsableTodo[]", "p", element); - wasParamCheckFailure = true; - } + logOrThrowExceptionHelper.ParameterBindingFailed("ParsableTodo[]", "p", element); + wasParamCheckFailure = true; } - p_local[i] = parsed_element!; } + p_local[i] = parsed_element!; + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "application/json"; - var result = handler(p_local!); - return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "application/json"; + var result = handler(p_local!); + return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[], IsOptional = False, IsParsable = True, IsArray = True, Source = RouteOrQuery) + var p_raw = p_RouteOrQueryResolver(httpContext); + var p_temp = p_raw.ToArray(); + global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[] p_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[p_temp.Length]; + for (var i = 0; i < p_temp.Length; i++) { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[], IsOptional = False, IsParsable = True, IsArray = True, Source = RouteOrQuery) - var p_raw = p_RouteOrQueryResolver(httpContext); - var p_temp = p_raw.ToArray(); - global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[] p_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParsableTodo[p_temp.Length]; - for (var i = 0; i < p_temp.Length; i++) + var element = p_temp[i]; + if (!GeneratedRouteBuilderExtensionsCore.TryParseExplicit(element!, CultureInfo.InvariantCulture, out var parsed_element)) { - var element = p_temp[i]; - if (!GeneratedRouteBuilderExtensionsCore.TryParseExplicit(element!, CultureInfo.InvariantCulture, out var parsed_element)) + if (!string.IsNullOrEmpty(element)) { - if (!string.IsNullOrEmpty(element)) - { - logOrThrowExceptionHelper.ParameterBindingFailed("ParsableTodo[]", "p", element); - wasParamCheckFailure = true; - } + logOrThrowExceptionHelper.ParameterBindingFailed("ParsableTodo[]", "p", element); + wasParamCheckFailure = true; } - p_local[i] = parsed_element!; } + p_local[i] = parsed_element!; + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local!)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local!)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ImplicitQuery_NullableStringArrayParam.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ImplicitQuery_NullableStringArrayParam.generated.txt index d4286778fe3b..16bbeced43c2 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ImplicitQuery_NullableStringArrayParam.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ImplicitQuery_NullableStringArrayParam.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,95 +68,115 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.Int32 (global::System.String?[] arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; + var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; - var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string?[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) - var p_raw = httpContext.Request.Query["p"]; - var p_temp = p_raw.ToArray(); - string[] p_local = p_temp!; + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string?[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) + var p_raw = httpContext.Request.Query["p"]; + var p_temp = p_raw.ToArray(); + string[] p_local = p_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "application/json"; - var result = handler(p_local); - return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "application/json"; + var result = handler(p_local); + return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + } - async Task RequestHandlerFiltered(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string?[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) - var p_raw = httpContext.Request.Query["p"]; - var p_temp = p_raw.ToArray(); - string[] p_local = p_temp!; + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string?[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) + var p_raw = httpContext.Request.Query["p"]; + var p_temp = p_raw.ToArray(); + string[] p_local = p_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ImplicitQuery_NullableStringArrayParam_EmptyQueryValues.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ImplicitQuery_NullableStringArrayParam_EmptyQueryValues.generated.txt index d4286778fe3b..16bbeced43c2 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ImplicitQuery_NullableStringArrayParam_EmptyQueryValues.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ImplicitQuery_NullableStringArrayParam_EmptyQueryValues.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,95 +68,115 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.Int32 (global::System.String?[] arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; + var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; - var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string?[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) - var p_raw = httpContext.Request.Query["p"]; - var p_temp = p_raw.ToArray(); - string[] p_local = p_temp!; + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string?[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) + var p_raw = httpContext.Request.Query["p"]; + var p_temp = p_raw.ToArray(); + string[] p_local = p_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "application/json"; - var result = handler(p_local); - return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "application/json"; + var result = handler(p_local); + return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + } - async Task RequestHandlerFiltered(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string?[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) - var p_raw = httpContext.Request.Query["p"]; - var p_temp = p_raw.ToArray(); - string[] p_local = p_temp!; + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string?[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) + var p_raw = httpContext.Request.Query["p"]; + var p_temp = p_raw.ToArray(); + string[] p_local = p_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ImplicitQuery_NullableStringArrayParam_QueryNotPresent.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ImplicitQuery_NullableStringArrayParam_QueryNotPresent.generated.txt index d4286778fe3b..16bbeced43c2 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ImplicitQuery_NullableStringArrayParam_QueryNotPresent.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ImplicitQuery_NullableStringArrayParam_QueryNotPresent.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,95 +68,115 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.Int32 (global::System.String?[] arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; + var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; - var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string?[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) - var p_raw = httpContext.Request.Query["p"]; - var p_temp = p_raw.ToArray(); - string[] p_local = p_temp!; + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string?[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) + var p_raw = httpContext.Request.Query["p"]; + var p_temp = p_raw.ToArray(); + string[] p_local = p_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "application/json"; - var result = handler(p_local); - return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "application/json"; + var result = handler(p_local); + return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + } - async Task RequestHandlerFiltered(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string?[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) - var p_raw = httpContext.Request.Query["p"]; - var p_temp = p_raw.ToArray(); - string[] p_local = p_temp!; + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string?[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) + var p_raw = httpContext.Request.Query["p"]; + var p_temp = p_raw.ToArray(); + string[] p_local = p_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ImplicitQuery_StringArrayParam.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ImplicitQuery_StringArrayParam.generated.txt index 7965ed87b87b..9b3838996817 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ImplicitQuery_StringArrayParam.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ImplicitQuery_StringArrayParam.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,95 +68,115 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.Int32 (global::System.String[] arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; + var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; - var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) - var p_raw = httpContext.Request.Query["p"]; - var p_temp = p_raw.ToArray(); - string[] p_local = p_temp!; + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) + var p_raw = httpContext.Request.Query["p"]; + var p_temp = p_raw.ToArray(); + string[] p_local = p_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "application/json"; - var result = handler(p_local); - return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "application/json"; + var result = handler(p_local); + return httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + } - async Task RequestHandlerFiltered(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) - var p_raw = httpContext.Request.Query["p"]; - var p_temp = p_raw.ToArray(); - string[] p_local = p_temp!; + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string[], IsOptional = False, IsParsable = False, IsArray = True, Source = Query) + var p_raw = httpContext.Request.Query["p"]; + var p_temp = p_raw.ToArray(); + string[] p_local = p_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_JsonBodyOrService_HandlesBothJsonAndService.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_JsonBodyOrService_HandlesBothJsonAndService.generated.txt index 0b9abf4ba91d..64545ddc8750 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_JsonBodyOrService_HandlesBothJsonAndService.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_JsonBodyOrService_HandlesBothJsonAndService.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapPost( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - PostVerb, - filePath, - lineNumber); } - } } @@ -88,131 +68,151 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapPost_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var serviceProviderIsService = serviceProvider.GetRequiredService(); + var jsonBodyOrServiceTypeTuples = new (bool, Type)[] { + (false, typeof(global::Microsoft.AspNetCore.Http.Generators.Tests.Todo)), + (false, typeof(global::Microsoft.AspNetCore.Http.Generators.Tests.TestService)), + }; + foreach (var (isOptional, type) in jsonBodyOrServiceTypeTuples) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var serviceProviderIsService = serviceProvider.GetRequiredService(); - var jsonBodyOrServiceTypeTuples = new (bool, Type)[] { - (false, typeof(global::Microsoft.AspNetCore.Http.Generators.Tests.Todo)), - (false, typeof(global::Microsoft.AspNetCore.Http.Generators.Tests.TestService)), - }; - foreach (var (isOptional, type) in jsonBodyOrServiceTypeTuples) + if (!serviceProviderIsService.IsService(type)) { - if (!serviceProviderIsService.IsService(type)) - { - options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(type: type, isOptional: isOptional, contentTypes: GeneratedMetadataConstants.JsonContentType)); - break; - } + options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(type: type, isOptional: isOptional, contentTypes: GeneratedMetadataConstants.JsonContentType)); + break; } - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + } + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.Generators.Tests.Todo arg0, global::Microsoft.AspNetCore.Http.Generators.Tests.TestService arg1) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var serviceProviderIsService = serviceProvider?.GetService(); + var todo_JsonBodyOrServiceResolver = ResolveJsonBodyOrService(logOrThrowExceptionHelper, "Todo", "todo", serviceProviderIsService); + var svc_JsonBodyOrServiceResolver = ResolveJsonBodyOrService(logOrThrowExceptionHelper, "TestService", "svc", serviceProviderIsService); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var serviceProviderIsService = serviceProvider?.GetService(); - var todo_JsonBodyOrServiceResolver = ResolveJsonBodyOrService(logOrThrowExceptionHelper, "Todo", "todo", serviceProviderIsService); - var svc_JsonBodyOrServiceResolver = ResolveJsonBodyOrService(logOrThrowExceptionHelper, "TestService", "svc", serviceProviderIsService); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); + }, + options.EndpointBuilder, + handler.Method); + } - async Task RequestHandler(HttpContext httpContext) + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: todo (Type = Microsoft.AspNetCore.Http.Generators.Tests.Todo, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBodyOrService) + var todo_resolveJsonBodyOrServiceResult = await todo_JsonBodyOrServiceResolver(httpContext, false); + var todo_local = todo_resolveJsonBodyOrServiceResult.Item2; + if (!todo_resolveJsonBodyOrServiceResult.Item1) { - var wasParamCheckFailure = false; - // Endpoint Parameter: todo (Type = Microsoft.AspNetCore.Http.Generators.Tests.Todo, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBodyOrService) - var todo_resolveJsonBodyOrServiceResult = await todo_JsonBodyOrServiceResolver(httpContext, false); - var todo_local = todo_resolveJsonBodyOrServiceResult.Item2; - if (!todo_resolveJsonBodyOrServiceResult.Item1) - { - return; - } - // Endpoint Parameter: svc (Type = Microsoft.AspNetCore.Http.Generators.Tests.TestService, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBodyOrService) - var svc_resolveJsonBodyOrServiceResult = await svc_JsonBodyOrServiceResolver(httpContext, false); - var svc_local = svc_resolveJsonBodyOrServiceResult.Item2; - if (!svc_resolveJsonBodyOrServiceResult.Item1) - { - return; - } + return; + } + // Endpoint Parameter: svc (Type = Microsoft.AspNetCore.Http.Generators.Tests.TestService, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBodyOrService) + var svc_resolveJsonBodyOrServiceResult = await svc_JsonBodyOrServiceResolver(httpContext, false); + var svc_local = svc_resolveJsonBodyOrServiceResult.Item2; + if (!svc_resolveJsonBodyOrServiceResult.Item1) + { + return; + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(todo_local!, svc_local!); - await httpContext.Response.WriteAsync(result); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(todo_local!, svc_local!); + await httpContext.Response.WriteAsync(result); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: todo (Type = Microsoft.AspNetCore.Http.Generators.Tests.Todo, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBodyOrService) + var todo_resolveJsonBodyOrServiceResult = await todo_JsonBodyOrServiceResolver(httpContext, false); + var todo_local = todo_resolveJsonBodyOrServiceResult.Item2; + if (!todo_resolveJsonBodyOrServiceResult.Item1) { - var wasParamCheckFailure = false; - // Endpoint Parameter: todo (Type = Microsoft.AspNetCore.Http.Generators.Tests.Todo, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBodyOrService) - var todo_resolveJsonBodyOrServiceResult = await todo_JsonBodyOrServiceResolver(httpContext, false); - var todo_local = todo_resolveJsonBodyOrServiceResult.Item2; - if (!todo_resolveJsonBodyOrServiceResult.Item1) - { - return; - } - // Endpoint Parameter: svc (Type = Microsoft.AspNetCore.Http.Generators.Tests.TestService, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBodyOrService) - var svc_resolveJsonBodyOrServiceResult = await svc_JsonBodyOrServiceResolver(httpContext, false); - var svc_local = svc_resolveJsonBodyOrServiceResult.Item2; - if (!svc_resolveJsonBodyOrServiceResult.Item1) - { - return; - } + return; + } + // Endpoint Parameter: svc (Type = Microsoft.AspNetCore.Http.Generators.Tests.TestService, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBodyOrService) + var svc_resolveJsonBodyOrServiceResult = await svc_JsonBodyOrServiceResolver(httpContext, false); + var svc_local = svc_resolveJsonBodyOrServiceResult.Item2; + if (!svc_resolveJsonBodyOrServiceResult.Item1) + { + return; + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, todo_local!, svc_local!)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, todo_local!, svc_local!)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + PostVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_MultipleSpecialTypeParam_StringReturn.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_MultipleSpecialTypeParam_StringReturn.generated.txt index bb3f7d1a88e1..e1bba69fcb78 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_MultipleSpecialTypeParam_StringReturn.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_MultipleSpecialTypeParam_StringReturn.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,88 +68,108 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.HttpRequest arg0, global::Microsoft.AspNetCore.Http.HttpResponse arg1) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var req_local = httpContext.Request; - var res_local = httpContext.Response; + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var req_local = httpContext.Request; + var res_local = httpContext.Response; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(req_local, res_local); - return httpContext.Response.WriteAsync(result); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(req_local, res_local); + return httpContext.Response.WriteAsync(result); + } - async Task RequestHandlerFiltered(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var req_local = httpContext.Request; - var res_local = httpContext.Response; + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var req_local = httpContext.Request; + var res_local = httpContext.Response; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, req_local, res_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, req_local, res_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_MultipleStringParam_StringReturn.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_MultipleStringParam_StringReturn.generated.txt index a84bcd89ceda..5dabff306eae 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_MultipleStringParam_StringReturn.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_MultipleStringParam_StringReturn.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,122 +68,142 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::System.String arg0, global::System.String arg1) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p1 (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Query) + var p1_raw = httpContext.Request.Query["p1"]; + if (StringValues.IsNullOrEmpty(p1_raw)) { - var wasParamCheckFailure = false; - // Endpoint Parameter: p1 (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Query) - var p1_raw = httpContext.Request.Query["p1"]; - if (StringValues.IsNullOrEmpty(p1_raw)) - { - wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "p1", "query string"); - } - var p1_temp = (string?)p1_raw; - string p1_local = p1_temp!; - // Endpoint Parameter: p2 (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Query) - var p2_raw = httpContext.Request.Query["p2"]; - if (StringValues.IsNullOrEmpty(p2_raw)) - { - wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "p2", "query string"); - } - var p2_temp = (string?)p2_raw; - string p2_local = p2_temp!; + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "p1", "query string"); + } + var p1_temp = (string?)p1_raw; + string p1_local = p1_temp!; + // Endpoint Parameter: p2 (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Query) + var p2_raw = httpContext.Request.Query["p2"]; + if (StringValues.IsNullOrEmpty(p2_raw)) + { + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "p2", "query string"); + } + var p2_temp = (string?)p2_raw; + string p2_local = p2_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(p1_local, p2_local); - return httpContext.Response.WriteAsync(result); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(p1_local, p2_local); + return httpContext.Response.WriteAsync(result); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p1 (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Query) + var p1_raw = httpContext.Request.Query["p1"]; + if (StringValues.IsNullOrEmpty(p1_raw)) { - var wasParamCheckFailure = false; - // Endpoint Parameter: p1 (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Query) - var p1_raw = httpContext.Request.Query["p1"]; - if (StringValues.IsNullOrEmpty(p1_raw)) - { - wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "p1", "query string"); - } - var p1_temp = (string?)p1_raw; - string p1_local = p1_temp!; - // Endpoint Parameter: p2 (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Query) - var p2_raw = httpContext.Request.Query["p2"]; - if (StringValues.IsNullOrEmpty(p2_raw)) - { - wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "p2", "query string"); - } - var p2_temp = (string?)p2_raw; - string p2_local = p2_temp!; + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "p1", "query string"); + } + var p1_temp = (string?)p1_raw; + string p1_local = p1_temp!; + // Endpoint Parameter: p2 (Type = string, IsOptional = False, IsParsable = False, IsArray = False, Source = Query) + var p2_raw = httpContext.Request.Query["p2"]; + if (StringValues.IsNullOrEmpty(p2_raw)) + { + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("string", "p2", "query string"); + } + var p2_temp = (string?)p2_raw; + string p2_local = p2_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p1_local, p2_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p1_local, p2_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_NoParam_StringReturn_WithFilter.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_NoParam_StringReturn_WithFilter.generated.txt index beffb24eb86d..23f35d3fad14 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_NoParam_StringReturn_WithFilter.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_NoParam_StringReturn_WithFilter.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,82 +68,102 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String () => throw null!); + EndpointFilterDelegate? filteredInvocation = null; - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler()); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler()); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(); - return httpContext.Response.WriteAsync(result); + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(); + return httpContext.Response.WriteAsync(result); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ReturnsString_Has_Metadata.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ReturnsString_Has_Metadata.generated.txt index beffb24eb86d..23f35d3fad14 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ReturnsString_Has_Metadata.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ReturnsString_Has_Metadata.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,82 +68,102 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String () => throw null!); + EndpointFilterDelegate? filteredInvocation = null; - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler()); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler()); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(); - return httpContext.Response.WriteAsync(result); + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(); + return httpContext.Response.WriteAsync(result); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ReturnsTodo_Has_Metadata.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ReturnsTodo_Has_Metadata.generated.txt index 3c311eaae2ec..32e3833efe0e 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ReturnsTodo_Has_Metadata.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ReturnsTodo_Has_Metadata.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,85 +68,105 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::Microsoft.AspNetCore.Http.Generators.Tests.Todo), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::Microsoft.AspNetCore.Http.Generators.Tests.Todo), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::Microsoft.AspNetCore.Http.Generators.Tests.Todo () => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; + var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::Microsoft.AspNetCore.Http.Generators.Tests.Todo)); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; - var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::Microsoft.AspNetCore.Http.Generators.Tests.Todo)); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler()); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler()); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "application/json"; - var result = handler(); - return GeneratedRouteBuilderExtensionsCore.WriteToResponseAsync(result, httpContext, jsonTypeInfo); + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "application/json"; + var result = handler(); + return GeneratedRouteBuilderExtensionsCore.WriteToResponseAsync(result, httpContext, jsonTypeInfo); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ReturnsValidationProblemResult_Has_Metadata.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ReturnsValidationProblemResult_Has_Metadata.generated.txt index 5ea238b3fbb1..581cb67d36c9 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ReturnsValidationProblemResult_Has_Metadata.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ReturnsValidationProblemResult_Has_Metadata.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,81 +68,101 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - PopulateMetadataForEndpoint(methodInfo, options.EndpointBuilder); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + PopulateMetadataForEndpoint(methodInfo, options.EndpointBuilder); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::Microsoft.AspNetCore.Http.HttpResults.ValidationProblem () => throw null!); + EndpointFilterDelegate? filteredInvocation = null; - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler()); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler()); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - var result = handler(); - return GeneratedRouteBuilderExtensionsCore.ExecuteAsyncExplicit(result, httpContext); + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + var result = handler(); + return GeneratedRouteBuilderExtensionsCore.ExecuteAsyncExplicit(result, httpContext); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ReturnsVoid_Has_No_Metadata.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ReturnsVoid_Has_No_Metadata.generated.txt index c600bc7323b9..116004e78786 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ReturnsVoid_Has_No_Metadata.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_ReturnsVoid_Has_No_Metadata.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Action handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,81 +68,101 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Action)del; - EndpointFilterDelegate? filteredInvocation = null; + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, void () => throw null!); + EndpointFilterDelegate? filteredInvocation = null; - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - handler(); return ValueTask.FromResult(Results.Empty); - }, - options.EndpointBuilder, - handler.Method); - } - - Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; } handler(); + return ValueTask.FromResult(Results.Empty); + }, + options.EndpointBuilder, + handler.Method); + } + + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; return Task.CompletedTask; } + handler(); + return Task.CompletedTask; + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_SingleComplexTypeParam_StringReturn.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_SingleComplexTypeParam_StringReturn.generated.txt index dfe9f48217f0..b244c78c9400 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_SingleComplexTypeParam_StringReturn.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_SingleComplexTypeParam_StringReturn.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,120 +68,140 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.Generators.Tests.TryParseTodo arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = Microsoft.AspNetCore.Http.Generators.Tests.TryParseTodo, IsOptional = False, IsParsable = True, IsArray = False, Source = Query) + var p_raw = httpContext.Request.Query["p"]; + if (StringValues.IsNullOrEmpty(p_raw)) + { + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("TryParseTodo", "p", "query string"); + } + var p_temp = (string?)p_raw; + if (!global::Microsoft.AspNetCore.Http.Generators.Tests.TryParseTodo.TryParse(p_temp!, out var p_parsed_temp)) { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = Microsoft.AspNetCore.Http.Generators.Tests.TryParseTodo, IsOptional = False, IsParsable = True, IsArray = False, Source = Query) - var p_raw = httpContext.Request.Query["p"]; - if (StringValues.IsNullOrEmpty(p_raw)) + if (!string.IsNullOrEmpty(p_temp)) { + logOrThrowExceptionHelper.ParameterBindingFailed("TryParseTodo", "p", p_temp); wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("TryParseTodo", "p", "query string"); - } - var p_temp = (string?)p_raw; - if (!global::Microsoft.AspNetCore.Http.Generators.Tests.TryParseTodo.TryParse(p_temp!, out var p_parsed_temp)) - { - if (!string.IsNullOrEmpty(p_temp)) - { - logOrThrowExceptionHelper.ParameterBindingFailed("TryParseTodo", "p", p_temp); - wasParamCheckFailure = true; - } } - global::Microsoft.AspNetCore.Http.Generators.Tests.TryParseTodo p_local = p_parsed_temp!; + } + global::Microsoft.AspNetCore.Http.Generators.Tests.TryParseTodo p_local = p_parsed_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(p_local); - return httpContext.Response.WriteAsync(result); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(p_local); + return httpContext.Response.WriteAsync(result); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = Microsoft.AspNetCore.Http.Generators.Tests.TryParseTodo, IsOptional = False, IsParsable = True, IsArray = False, Source = Query) + var p_raw = httpContext.Request.Query["p"]; + if (StringValues.IsNullOrEmpty(p_raw)) + { + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("TryParseTodo", "p", "query string"); + } + var p_temp = (string?)p_raw; + if (!global::Microsoft.AspNetCore.Http.Generators.Tests.TryParseTodo.TryParse(p_temp!, out var p_parsed_temp)) { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = Microsoft.AspNetCore.Http.Generators.Tests.TryParseTodo, IsOptional = False, IsParsable = True, IsArray = False, Source = Query) - var p_raw = httpContext.Request.Query["p"]; - if (StringValues.IsNullOrEmpty(p_raw)) + if (!string.IsNullOrEmpty(p_temp)) { + logOrThrowExceptionHelper.ParameterBindingFailed("TryParseTodo", "p", p_temp); wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("TryParseTodo", "p", "query string"); } - var p_temp = (string?)p_raw; - if (!global::Microsoft.AspNetCore.Http.Generators.Tests.TryParseTodo.TryParse(p_temp!, out var p_parsed_temp)) - { - if (!string.IsNullOrEmpty(p_temp)) - { - logOrThrowExceptionHelper.ParameterBindingFailed("TryParseTodo", "p", p_temp); - wasParamCheckFailure = true; - } - } - global::Microsoft.AspNetCore.Http.Generators.Tests.TryParseTodo p_local = p_parsed_temp!; + } + global::Microsoft.AspNetCore.Http.Generators.Tests.TryParseTodo p_local = p_parsed_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_SingleEnumParam_StringReturn.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_SingleEnumParam_StringReturn.generated.txt index 5931f46bb814..4df17f1bb08d 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_SingleEnumParam_StringReturn.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_SingleEnumParam_StringReturn.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,120 +68,140 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.Generators.Tests.TodoStatus arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = Microsoft.AspNetCore.Http.Generators.Tests.TodoStatus, IsOptional = False, IsParsable = True, IsArray = False, Source = Query) + var p_raw = httpContext.Request.Query["p"]; + if (StringValues.IsNullOrEmpty(p_raw)) + { + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("TodoStatus", "p", "query string"); + } + var p_temp = (string?)p_raw; + if (!Enum.TryParse(p_temp!, out var p_parsed_temp)) { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = Microsoft.AspNetCore.Http.Generators.Tests.TodoStatus, IsOptional = False, IsParsable = True, IsArray = False, Source = Query) - var p_raw = httpContext.Request.Query["p"]; - if (StringValues.IsNullOrEmpty(p_raw)) + if (!string.IsNullOrEmpty(p_temp)) { + logOrThrowExceptionHelper.ParameterBindingFailed("TodoStatus", "p", p_temp); wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("TodoStatus", "p", "query string"); - } - var p_temp = (string?)p_raw; - if (!Enum.TryParse(p_temp!, out var p_parsed_temp)) - { - if (!string.IsNullOrEmpty(p_temp)) - { - logOrThrowExceptionHelper.ParameterBindingFailed("TodoStatus", "p", p_temp); - wasParamCheckFailure = true; - } } - global::Microsoft.AspNetCore.Http.Generators.Tests.TodoStatus p_local = p_parsed_temp!; + } + global::Microsoft.AspNetCore.Http.Generators.Tests.TodoStatus p_local = p_parsed_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(p_local); - return httpContext.Response.WriteAsync(result); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(p_local); + return httpContext.Response.WriteAsync(result); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = Microsoft.AspNetCore.Http.Generators.Tests.TodoStatus, IsOptional = False, IsParsable = True, IsArray = False, Source = Query) + var p_raw = httpContext.Request.Query["p"]; + if (StringValues.IsNullOrEmpty(p_raw)) + { + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("TodoStatus", "p", "query string"); + } + var p_temp = (string?)p_raw; + if (!Enum.TryParse(p_temp!, out var p_parsed_temp)) { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = Microsoft.AspNetCore.Http.Generators.Tests.TodoStatus, IsOptional = False, IsParsable = True, IsArray = False, Source = Query) - var p_raw = httpContext.Request.Query["p"]; - if (StringValues.IsNullOrEmpty(p_raw)) + if (!string.IsNullOrEmpty(p_temp)) { + logOrThrowExceptionHelper.ParameterBindingFailed("TodoStatus", "p", p_temp); wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("TodoStatus", "p", "query string"); } - var p_temp = (string?)p_raw; - if (!Enum.TryParse(p_temp!, out var p_parsed_temp)) - { - if (!string.IsNullOrEmpty(p_temp)) - { - logOrThrowExceptionHelper.ParameterBindingFailed("TodoStatus", "p", p_temp); - wasParamCheckFailure = true; - } - } - global::Microsoft.AspNetCore.Http.Generators.Tests.TodoStatus p_local = p_parsed_temp!; + } + global::Microsoft.AspNetCore.Http.Generators.Tests.TodoStatus p_local = p_parsed_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_SingleNullableStringParam_WithEmptyQueryStringValueProvided_StringReturn.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_SingleNullableStringParam_WithEmptyQueryStringValueProvided_StringReturn.generated.txt index ff0e515204ed..a0f823009cfd 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_SingleNullableStringParam_WithEmptyQueryStringValueProvided_StringReturn.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_SingleNullableStringParam_WithEmptyQueryStringValueProvided_StringReturn.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -88,94 +68,114 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::System.String? arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string?, IsOptional = True, IsParsable = False, IsArray = False, Source = Query) - var p_raw = httpContext.Request.Query["p"]; - var p_temp = p_raw.Count > 0 ? (string?)p_raw : null; - string p_local = p_temp!; + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string?, IsOptional = True, IsParsable = False, IsArray = False, Source = Query) + var p_raw = httpContext.Request.Query["p"]; + var p_temp = p_raw.Count > 0 ? (string?)p_raw : null; + string p_local = p_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(p_local); - return httpContext.Response.WriteAsync(result); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(p_local); + return httpContext.Response.WriteAsync(result); + } - async Task RequestHandlerFiltered(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string?, IsOptional = True, IsParsable = False, IsArray = False, Source = Query) - var p_raw = httpContext.Request.Query["p"]; - var p_temp = p_raw.Count > 0 ? (string?)p_raw : null; - string p_local = p_temp!; + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string?, IsOptional = True, IsParsable = False, IsArray = False, Source = Query) + var p_raw = httpContext.Request.Query["p"]; + var p_temp = p_raw.Count > 0 ? (string?)p_raw : null; + string p_local = p_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_TakesCustomMetadataEmitter_Has_Metadata.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_TakesCustomMetadataEmitter_Has_Metadata.generated.txt index d51d5806bd87..0b8240c7d6ae 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_TakesCustomMetadataEmitter_Has_Metadata.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapAction_TakesCustomMetadataEmitter_Has_Metadata.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapPost( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Action handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - PostVerb, - filePath, - lineNumber); } - } } @@ -88,117 +68,137 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapPost_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var serviceProviderIsService = serviceProvider.GetRequiredService(); + var jsonBodyOrServiceTypeTuples = new (bool, Type)[] { + (false, typeof(global::Microsoft.AspNetCore.Http.Generators.Tests.CustomMetadataEmitter)), + }; + foreach (var (isOptional, type) in jsonBodyOrServiceTypeTuples) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var serviceProviderIsService = serviceProvider.GetRequiredService(); - var jsonBodyOrServiceTypeTuples = new (bool, Type)[] { - (false, typeof(global::Microsoft.AspNetCore.Http.Generators.Tests.CustomMetadataEmitter)), - }; - foreach (var (isOptional, type) in jsonBodyOrServiceTypeTuples) + if (!serviceProviderIsService.IsService(type)) { - if (!serviceProviderIsService.IsService(type)) - { - options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(type: type, isOptional: isOptional, contentTypes: GeneratedMetadataConstants.JsonContentType)); - break; - } + options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(type: type, isOptional: isOptional, contentTypes: GeneratedMetadataConstants.JsonContentType)); + break; } - var parameterInfos = methodInfo.GetParameters(); - var x_ParameterInfo = parameterInfos[0]; - PopulateMetadataForParameter(x_ParameterInfo, options.EndpointBuilder); - PopulateMetadataForEndpoint(methodInfo, options.EndpointBuilder); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + } + var parameterInfos = methodInfo.GetParameters(); + var x_ParameterInfo = parameterInfos[0]; + PopulateMetadataForParameter(x_ParameterInfo, options.EndpointBuilder); + PopulateMetadataForEndpoint(methodInfo, options.EndpointBuilder); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, void (global::Microsoft.AspNetCore.Http.Generators.Tests.CustomMetadataEmitter arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var serviceProviderIsService = serviceProvider?.GetService(); + var x_JsonBodyOrServiceResolver = ResolveJsonBodyOrService(logOrThrowExceptionHelper, "CustomMetadataEmitter", "x", serviceProviderIsService); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Action)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var serviceProviderIsService = serviceProvider?.GetService(); - var x_JsonBodyOrServiceResolver = ResolveJsonBodyOrService(logOrThrowExceptionHelper, "CustomMetadataEmitter", "x", serviceProviderIsService); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - handler(ic.GetArgument(0)!); return ValueTask.FromResult(Results.Empty); - }, - options.EndpointBuilder, - handler.Method); - } + } + handler(ic.GetArgument(0)!); + return ValueTask.FromResult(Results.Empty); + }, + options.EndpointBuilder, + handler.Method); + } - async Task RequestHandler(HttpContext httpContext) + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: x (Type = Microsoft.AspNetCore.Http.Generators.Tests.CustomMetadataEmitter, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBodyOrService) + var x_resolveJsonBodyOrServiceResult = await x_JsonBodyOrServiceResolver(httpContext, false); + var x_local = x_resolveJsonBodyOrServiceResult.Item2; + if (!x_resolveJsonBodyOrServiceResult.Item1) { - var wasParamCheckFailure = false; - // Endpoint Parameter: x (Type = Microsoft.AspNetCore.Http.Generators.Tests.CustomMetadataEmitter, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBodyOrService) - var x_resolveJsonBodyOrServiceResult = await x_JsonBodyOrServiceResolver(httpContext, false); - var x_local = x_resolveJsonBodyOrServiceResult.Item2; - if (!x_resolveJsonBodyOrServiceResult.Item1) - { - return; - } + return; + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - handler(x_local!); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return; } + handler(x_local!); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: x (Type = Microsoft.AspNetCore.Http.Generators.Tests.CustomMetadataEmitter, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBodyOrService) + var x_resolveJsonBodyOrServiceResult = await x_JsonBodyOrServiceResolver(httpContext, false); + var x_local = x_resolveJsonBodyOrServiceResult.Item2; + if (!x_resolveJsonBodyOrServiceResult.Item1) { - var wasParamCheckFailure = false; - // Endpoint Parameter: x (Type = Microsoft.AspNetCore.Http.Generators.Tests.CustomMetadataEmitter, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBodyOrService) - var x_resolveJsonBodyOrServiceResult = await x_JsonBodyOrServiceResolver(httpContext, false); - var x_local = x_resolveJsonBodyOrServiceResult.Item2; - if (!x_resolveJsonBodyOrServiceResult.Item1) - { - return; - } + return; + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, x_local!)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, x_local!)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + PostVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapPost_WithArrayQueryString_AndBody_ShouldUseBody.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapPost_WithArrayQueryString_AndBody_ShouldUseBody.generated.txt index ce2e1c9b2db7..a7af90e60cab 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapPost_WithArrayQueryString_AndBody_ShouldUseBody.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapPost_WithArrayQueryString_AndBody_ShouldUseBody.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapPost( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - PostVerb, - filePath, - lineNumber); } - } } @@ -88,115 +68,135 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapPost_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var serviceProviderIsService = serviceProvider.GetRequiredService(); + var jsonBodyOrServiceTypeTuples = new (bool, Type)[] { + (false, typeof(global::System.String[])), + }; + foreach (var (isOptional, type) in jsonBodyOrServiceTypeTuples) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var serviceProviderIsService = serviceProvider.GetRequiredService(); - var jsonBodyOrServiceTypeTuples = new (bool, Type)[] { - (false, typeof(global::System.String[])), - }; - foreach (var (isOptional, type) in jsonBodyOrServiceTypeTuples) + if (!serviceProviderIsService.IsService(type)) { - if (!serviceProviderIsService.IsService(type)) - { - options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(type: type, isOptional: isOptional, contentTypes: GeneratedMetadataConstants.JsonContentType)); - break; - } + options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(type: type, isOptional: isOptional, contentTypes: GeneratedMetadataConstants.JsonContentType)); + break; } - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + } + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::System.String[] arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var serviceProviderIsService = serviceProvider?.GetService(); + var p_JsonBodyOrServiceResolver = ResolveJsonBodyOrService(logOrThrowExceptionHelper, "string[]", "p", serviceProviderIsService); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var serviceProviderIsService = serviceProvider?.GetService(); - var p_JsonBodyOrServiceResolver = ResolveJsonBodyOrService(logOrThrowExceptionHelper, "string[]", "p", serviceProviderIsService); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - async Task RequestHandler(HttpContext httpContext) + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string[], IsOptional = False, IsParsable = False, IsArray = True, Source = JsonBodyOrService) + var p_resolveJsonBodyOrServiceResult = await p_JsonBodyOrServiceResolver(httpContext, false); + var p_local = p_resolveJsonBodyOrServiceResult.Item2; + if (!p_resolveJsonBodyOrServiceResult.Item1) { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string[], IsOptional = False, IsParsable = False, IsArray = True, Source = JsonBodyOrService) - var p_resolveJsonBodyOrServiceResult = await p_JsonBodyOrServiceResolver(httpContext, false); - var p_local = p_resolveJsonBodyOrServiceResult.Item2; - if (!p_resolveJsonBodyOrServiceResult.Item1) - { - return; - } + return; + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(p_local!); - await httpContext.Response.WriteAsync(result); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(p_local!); + await httpContext.Response.WriteAsync(result); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string[], IsOptional = False, IsParsable = False, IsArray = True, Source = JsonBodyOrService) + var p_resolveJsonBodyOrServiceResult = await p_JsonBodyOrServiceResolver(httpContext, false); + var p_local = p_resolveJsonBodyOrServiceResult.Item2; + if (!p_resolveJsonBodyOrServiceResult.Item1) { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string[], IsOptional = False, IsParsable = False, IsArray = True, Source = JsonBodyOrService) - var p_resolveJsonBodyOrServiceResult = await p_JsonBodyOrServiceResolver(httpContext, false); - var p_local = p_resolveJsonBodyOrServiceResult.Item2; - if (!p_resolveJsonBodyOrServiceResult.Item1) - { - return; - } + return; + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local!)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local!)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + PostVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapPost_WithArrayQueryString_ShouldFail.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapPost_WithArrayQueryString_ShouldFail.generated.txt index e28928eba33b..18b23c4f8c9b 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapPost_WithArrayQueryString_ShouldFail.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/MapPost_WithArrayQueryString_ShouldFail.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapPost( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - PostVerb, - filePath, - lineNumber); } - } } @@ -88,117 +68,137 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapPost_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var serviceProviderIsService = serviceProvider.GetRequiredService(); + var jsonBodyOrServiceTypeTuples = new (bool, Type)[] { + (false, typeof(global::System.String[])), + }; + foreach (var (isOptional, type) in jsonBodyOrServiceTypeTuples) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var serviceProviderIsService = serviceProvider.GetRequiredService(); - var jsonBodyOrServiceTypeTuples = new (bool, Type)[] { - (false, typeof(global::System.String[])), - }; - foreach (var (isOptional, type) in jsonBodyOrServiceTypeTuples) + if (!serviceProviderIsService.IsService(type)) { - if (!serviceProviderIsService.IsService(type)) - { - options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(type: type, isOptional: isOptional, contentTypes: GeneratedMetadataConstants.JsonContentType)); - break; - } + options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(type: type, isOptional: isOptional, contentTypes: GeneratedMetadataConstants.JsonContentType)); + break; } - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + } + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: typeof(global::System.Int32), statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.JsonContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.Int32 (global::System.String[] arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var serviceProviderIsService = serviceProvider?.GetService(); + var p_JsonBodyOrServiceResolver = ResolveJsonBodyOrService(logOrThrowExceptionHelper, "string[]", "p", serviceProviderIsService); + var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; + var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var serviceProviderIsService = serviceProvider?.GetService(); - var p_JsonBodyOrServiceResolver = ResolveJsonBodyOrService(logOrThrowExceptionHelper, "string[]", "p", serviceProviderIsService); - var serializerOptions = serviceProvider?.GetService>()?.Value.SerializerOptions ?? new JsonOptions().SerializerOptions; - var jsonTypeInfo = (JsonTypeInfo)serializerOptions.GetTypeInfo(typeof(global::System.Int32)); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - async Task RequestHandler(HttpContext httpContext) + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string[], IsOptional = False, IsParsable = False, IsArray = True, Source = JsonBodyOrService) + var p_resolveJsonBodyOrServiceResult = await p_JsonBodyOrServiceResolver(httpContext, false); + var p_local = p_resolveJsonBodyOrServiceResult.Item2; + if (!p_resolveJsonBodyOrServiceResult.Item1) { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string[], IsOptional = False, IsParsable = False, IsArray = True, Source = JsonBodyOrService) - var p_resolveJsonBodyOrServiceResult = await p_JsonBodyOrServiceResolver(httpContext, false); - var p_local = p_resolveJsonBodyOrServiceResult.Item2; - if (!p_resolveJsonBodyOrServiceResult.Item1) - { - return; - } + return; + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - httpContext.Response.ContentType ??= "application/json"; - var result = handler(p_local!); - await httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return; } + httpContext.Response.ContentType ??= "application/json"; + var result = handler(p_local!); + await httpContext.Response.WriteAsJsonAsync(result, jsonTypeInfo); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: p (Type = string[], IsOptional = False, IsParsable = False, IsArray = True, Source = JsonBodyOrService) + var p_resolveJsonBodyOrServiceResult = await p_JsonBodyOrServiceResolver(httpContext, false); + var p_local = p_resolveJsonBodyOrServiceResult.Item2; + if (!p_resolveJsonBodyOrServiceResult.Item1) { - var wasParamCheckFailure = false; - // Endpoint Parameter: p (Type = string[], IsOptional = False, IsParsable = False, IsArray = True, Source = JsonBodyOrService) - var p_resolveJsonBodyOrServiceResult = await p_JsonBodyOrServiceResolver(httpContext, false); - var p_local = p_resolveJsonBodyOrServiceResult.Item2; - if (!p_resolveJsonBodyOrServiceResult.Item1) - { - return; - } + return; + } - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local!)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, p_local!)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + PostVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/Multiple_MapAction_NoParam_StringReturn.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/Multiple_MapAction_NoParam_StringReturn.generated.txt index 71d6b29f0e3d..de6239de865f 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/Multiple_MapAction_NoParam_StringReturn.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/Multiple_MapAction_NoParam_StringReturn.generated.txt @@ -22,67 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func> handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) - { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); - } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func> handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) - { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); - } - } } @@ -118,258 +68,320 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) - { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler()); - }, - options.EndpointBuilder, - handler.Method); - } + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String () => throw null!); + EndpointFilterDelegate? filteredInvocation = null; - Task RequestHandler(HttpContext httpContext) + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - var wasParamCheckFailure = false; - if (wasParamCheckFailure) + if (ic.HttpContext.Response.StatusCode == 400) { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; + return ValueTask.FromResult(Results.Empty); } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(); - return httpContext.Response.WriteAsync(result); - } + return ValueTask.FromResult(handler()); + }, + options.EndpointBuilder, + handler.Method); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(); + return httpContext.Response.WriteAsync(result); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 26)] = ( - (methodInfo, options) => + async Task RequestHandlerFiltered(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 26)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + var wasParamCheckFailure = false; + if (wasParamCheckFailure) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler()); - }, - options.EndpointBuilder, - handler.Method); + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } - Task RequestHandler(HttpContext httpContext) + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } + +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 26, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_26( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 26)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String () => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - var wasParamCheckFailure = false; - if (wasParamCheckFailure) + if (ic.HttpContext.Response.StatusCode == 400) { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; + return ValueTask.FromResult(Results.Empty); } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(); - return httpContext.Response.WriteAsync(result); - } + return ValueTask.FromResult(handler()); + }, + options.EndpointBuilder, + handler.Method); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(); + return httpContext.Response.WriteAsync(result); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 27)] = ( - (methodInfo, options) => + async Task RequestHandlerFiltered(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 27)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func>)del; - EndpointFilterDelegate? filteredInvocation = null; - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + var wasParamCheckFailure = false; + if (wasParamCheckFailure) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(async ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - var result = await handler(); - return (object?)result; - }, - options.EndpointBuilder, - handler.Method); + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - async Task RequestHandler(HttpContext httpContext) +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 27, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_27( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 27)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.Threading.Tasks.Task () => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(async ic => { - var wasParamCheckFailure = false; - if (wasParamCheckFailure) + if (ic.HttpContext.Response.StatusCode == 400) { - httpContext.Response.StatusCode = 400; - return; + return ValueTask.FromResult(Results.Empty); } - httpContext.Response.ContentType ??= "application/json"; var result = await handler(); - await httpContext.Response.WriteAsync(result); - } + return (object?)result; + }, + options.EndpointBuilder, + handler.Method); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + httpContext.Response.StatusCode = 400; + return; } + httpContext.Response.ContentType ??= "application/json"; + var result = await handler(); + await httpContext.Response.WriteAsync(result); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 28)] = ( - (methodInfo, options) => + async Task RequestHandlerFiltered(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 28)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func>)del; - EndpointFilterDelegate? filteredInvocation = null; - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + var wasParamCheckFailure = false; + if (wasParamCheckFailure) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(async ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - var result = await handler(); - return (object?)result; - }, - options.EndpointBuilder, - handler.Method); + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - async Task RequestHandler(HttpContext httpContext) +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 28, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_28( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 28)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.Threading.Tasks.ValueTask () => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(async ic => { - var wasParamCheckFailure = false; - if (wasParamCheckFailure) + if (ic.HttpContext.Response.StatusCode == 400) { - httpContext.Response.StatusCode = 400; - return; + return ValueTask.FromResult(Results.Empty); } - httpContext.Response.ContentType ??= "application/json"; var result = await handler(); - await httpContext.Response.WriteAsync(result); + return (object?)result; + }, + options.EndpointBuilder, + handler.Method); + } + + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return; } + httpContext.Response.ContentType ??= "application/json"; + var result = await handler(); + await httpContext.Response.WriteAsync(result); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/Multiple_MapAction_WithParams_StringReturn.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/Multiple_MapAction_WithParams_StringReturn.generated.txt index 085aba858bdb..33a32c6d6c65 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/Multiple_MapAction_WithParams_StringReturn.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/Multiple_MapAction_WithParams_StringReturn.generated.txt @@ -22,67 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) - { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); - } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); - } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) - { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - } } @@ -118,212 +68,260 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 25, 13)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_25( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 25)] = ( - (methodInfo, options) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.HttpRequest arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 25)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + { + if (ic.HttpContext.Response.StatusCode == 400) + { + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } + + Task RequestHandler(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; + var wasParamCheckFailure = false; + var req_local = httpContext.Request; - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + if (wasParamCheckFailure) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(req_local); + return httpContext.Response.WriteAsync(result); + } - Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var req_local = httpContext.Request; + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var req_local = httpContext.Request; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(req_local); - return httpContext.Response.WriteAsync(result); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, req_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } - async Task RequestHandlerFiltered(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var req_local = httpContext.Request; + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - if (wasParamCheckFailure) +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 26, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_26( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 26)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.HttpResponse arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + { + if (ic.HttpContext.Response.StatusCode == 400) { - httpContext.Response.StatusCode = 400; + return ValueTask.FromResult(Results.Empty); } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, req_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); - } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 26)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 26)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + Task RequestHandler(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; + var wasParamCheckFailure = false; + var res_local = httpContext.Response; - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + if (wasParamCheckFailure) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(res_local); + return httpContext.Response.WriteAsync(result); + } - Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var res_local = httpContext.Response; + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var res_local = httpContext.Response; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(res_local); - return httpContext.Response.WriteAsync(result); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, res_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } - async Task RequestHandlerFiltered(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var res_local = httpContext.Response; + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } + +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 27, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_27( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 27)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.HttpRequest arg0, global::Microsoft.AspNetCore.Http.HttpResponse arg1) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; - if (wasParamCheckFailure) + if (options?.EndpointBuilder?.FilterFactories.Count > 0) + { + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + { + if (ic.HttpContext.Response.StatusCode == 400) { - httpContext.Response.StatusCode = 400; + return ValueTask.FromResult(Results.Empty); } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, res_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); - } + return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); + }, + options.EndpointBuilder, + handler.Method); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 27)] = ( - (methodInfo, options) => + Task RequestHandler(HttpContext httpContext) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 27)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; + var wasParamCheckFailure = false; + var req_local = httpContext.Request; + var res_local = httpContext.Response; - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + if (wasParamCheckFailure) { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => - { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!, ic.GetArgument(1)!)); - }, - options.EndpointBuilder, - handler.Method); + httpContext.Response.StatusCode = 400; + return Task.CompletedTask; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(req_local, res_local); + return httpContext.Response.WriteAsync(result); + } - Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - var req_local = httpContext.Request; - var res_local = httpContext.Response; - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(req_local, res_local); - return httpContext.Response.WriteAsync(result); - } + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var req_local = httpContext.Request; + var res_local = httpContext.Response; - async Task RequestHandlerFiltered(HttpContext httpContext) + if (wasParamCheckFailure) { - var wasParamCheckFailure = false; - var req_local = httpContext.Request; - var res_local = httpContext.Response; - - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, req_local, res_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, req_local, res_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/RequestDelegateValidateGeneratedFormCode.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/RequestDelegateValidateGeneratedFormCode.generated.txt index f0a611c81299..020811a7c0f4 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/RequestDelegateValidateGeneratedFormCode.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/RequestDelegateValidateGeneratedFormCode.generated.txt @@ -22,37 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapPost( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Action handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - PostVerb, - filePath, - lineNumber); } - } } @@ -88,185 +68,205 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 29, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapPost_29( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 29)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 29)); - options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(contentTypes: GeneratedMetadataConstants.FormFileContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 29)); + options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(contentTypes: GeneratedMetadataConstants.FormFileContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, void (global::Microsoft.AspNetCore.Http.HttpContext arg0, global::Microsoft.AspNetCore.Http.IFormFile arg1, global::Microsoft.AspNetCore.Http.IFormFileCollection arg2, global::Microsoft.AspNetCore.Http.IFormCollection arg3, global::Microsoft.AspNetCore.Http.Generators.Tests.MyTryParseRecord arg4) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Action)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - handler(ic.GetArgument(0)!, ic.GetArgument(1)!, ic.GetArgument(2)!, ic.GetArgument(3)!, ic.GetArgument(4)!); return ValueTask.FromResult(Results.Empty); - }, - options.EndpointBuilder, - handler.Method); - } + } + handler(ic.GetArgument(0)!, ic.GetArgument(1)!, ic.GetArgument(2)!, ic.GetArgument(3)!, ic.GetArgument(4)!); + return ValueTask.FromResult(Results.Empty); + }, + options.EndpointBuilder, + handler.Method); + } - async Task RequestHandler(HttpContext httpContext) + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var httpContext_local = httpContext; + // Endpoint Parameter: file (Type = Microsoft.AspNetCore.Http.IFormFile, IsOptional = False, IsParsable = False, IsArray = False, Source = FormBody) + var file_resolveFormResult = await GeneratedRouteBuilderExtensionsCore.TryResolveFormAsync(httpContext, logOrThrowExceptionHelper, "IFormFile", "file"); + if (!file_resolveFormResult.Item1) { - var wasParamCheckFailure = false; - var httpContext_local = httpContext; - // Endpoint Parameter: file (Type = Microsoft.AspNetCore.Http.IFormFile, IsOptional = False, IsParsable = False, IsArray = False, Source = FormBody) - var file_resolveFormResult = await GeneratedRouteBuilderExtensionsCore.TryResolveFormAsync(httpContext, logOrThrowExceptionHelper, "IFormFile", "file"); - if (!file_resolveFormResult.Item1) - { - return; - } - var file_raw = httpContext.Request.Form.Files["file"]; - if (file_raw == null) - { - wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("IFormFile", "file", "form"); - } - var file_temp = file_raw; - global::Microsoft.AspNetCore.Http.IFormFile file_local = file_temp!; - // Endpoint Parameter: fileCollection (Type = Microsoft.AspNetCore.Http.IFormFileCollection, IsOptional = False, IsParsable = False, IsArray = False, Source = FormBody) - var fileCollection_raw = httpContext.Request.Form.Files; - if (fileCollection_raw == null) - { - wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("IFormFileCollection", "fileCollection", "form"); - } - var fileCollection_temp = fileCollection_raw; - global::Microsoft.AspNetCore.Http.IFormFileCollection fileCollection_local = fileCollection_temp!; - // Endpoint Parameter: collection (Type = Microsoft.AspNetCore.Http.IFormCollection, IsOptional = False, IsParsable = False, IsArray = False, Source = FormBody) - var collection_raw = httpContext.Request.Form; - if (collection_raw == null) - { - wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("IFormCollection", "collection", "form"); - } - var collection_temp = collection_raw; - global::Microsoft.AspNetCore.Http.IFormCollection collection_local = collection_temp!; - // Endpoint Parameter: tryParseRecord (Type = Microsoft.AspNetCore.Http.Generators.Tests.MyTryParseRecord, IsOptional = False, IsParsable = True, IsArray = False, Source = FormBody) - var tryParseRecord_raw = (string?)httpContext.Request.Form["tryParseRecord"]; - if (tryParseRecord_raw == null) + return; + } + var file_raw = httpContext.Request.Form.Files["file"]; + if (file_raw == null) + { + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("IFormFile", "file", "form"); + } + var file_temp = file_raw; + global::Microsoft.AspNetCore.Http.IFormFile file_local = file_temp!; + // Endpoint Parameter: fileCollection (Type = Microsoft.AspNetCore.Http.IFormFileCollection, IsOptional = False, IsParsable = False, IsArray = False, Source = FormBody) + var fileCollection_raw = httpContext.Request.Form.Files; + if (fileCollection_raw == null) + { + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("IFormFileCollection", "fileCollection", "form"); + } + var fileCollection_temp = fileCollection_raw; + global::Microsoft.AspNetCore.Http.IFormFileCollection fileCollection_local = fileCollection_temp!; + // Endpoint Parameter: collection (Type = Microsoft.AspNetCore.Http.IFormCollection, IsOptional = False, IsParsable = False, IsArray = False, Source = FormBody) + var collection_raw = httpContext.Request.Form; + if (collection_raw == null) + { + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("IFormCollection", "collection", "form"); + } + var collection_temp = collection_raw; + global::Microsoft.AspNetCore.Http.IFormCollection collection_local = collection_temp!; + // Endpoint Parameter: tryParseRecord (Type = Microsoft.AspNetCore.Http.Generators.Tests.MyTryParseRecord, IsOptional = False, IsParsable = True, IsArray = False, Source = FormBody) + var tryParseRecord_raw = (string?)httpContext.Request.Form["tryParseRecord"]; + if (tryParseRecord_raw == null) + { + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("MyTryParseRecord", "tryParseRecord", "form"); + } + var tryParseRecord_temp = tryParseRecord_raw; + if (!global::Microsoft.AspNetCore.Http.Generators.Tests.MyTryParseRecord.TryParse(tryParseRecord_temp!, out var tryParseRecord_parsed_temp)) + { + if (!string.IsNullOrEmpty(tryParseRecord_temp)) { + logOrThrowExceptionHelper.ParameterBindingFailed("MyTryParseRecord", "tryParseRecord", tryParseRecord_temp); wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("MyTryParseRecord", "tryParseRecord", "form"); - } - var tryParseRecord_temp = tryParseRecord_raw; - if (!global::Microsoft.AspNetCore.Http.Generators.Tests.MyTryParseRecord.TryParse(tryParseRecord_temp!, out var tryParseRecord_parsed_temp)) - { - if (!string.IsNullOrEmpty(tryParseRecord_temp)) - { - logOrThrowExceptionHelper.ParameterBindingFailed("MyTryParseRecord", "tryParseRecord", tryParseRecord_temp); - wasParamCheckFailure = true; - } } - global::Microsoft.AspNetCore.Http.Generators.Tests.MyTryParseRecord tryParseRecord_local = tryParseRecord_parsed_temp!; + } + global::Microsoft.AspNetCore.Http.Generators.Tests.MyTryParseRecord tryParseRecord_local = tryParseRecord_parsed_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - handler(httpContext_local, file_local!, fileCollection_local!, collection_local!, tryParseRecord_local!); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return; } + handler(httpContext_local, file_local!, fileCollection_local!, collection_local!, tryParseRecord_local!); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + var httpContext_local = httpContext; + // Endpoint Parameter: file (Type = Microsoft.AspNetCore.Http.IFormFile, IsOptional = False, IsParsable = False, IsArray = False, Source = FormBody) + var file_resolveFormResult = await GeneratedRouteBuilderExtensionsCore.TryResolveFormAsync(httpContext, logOrThrowExceptionHelper, "IFormFile", "file"); + if (!file_resolveFormResult.Item1) { - var wasParamCheckFailure = false; - var httpContext_local = httpContext; - // Endpoint Parameter: file (Type = Microsoft.AspNetCore.Http.IFormFile, IsOptional = False, IsParsable = False, IsArray = False, Source = FormBody) - var file_resolveFormResult = await GeneratedRouteBuilderExtensionsCore.TryResolveFormAsync(httpContext, logOrThrowExceptionHelper, "IFormFile", "file"); - if (!file_resolveFormResult.Item1) - { - return; - } - var file_raw = httpContext.Request.Form.Files["file"]; - if (file_raw == null) - { - wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("IFormFile", "file", "form"); - } - var file_temp = file_raw; - global::Microsoft.AspNetCore.Http.IFormFile file_local = file_temp!; - // Endpoint Parameter: fileCollection (Type = Microsoft.AspNetCore.Http.IFormFileCollection, IsOptional = False, IsParsable = False, IsArray = False, Source = FormBody) - var fileCollection_raw = httpContext.Request.Form.Files; - if (fileCollection_raw == null) - { - wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("IFormFileCollection", "fileCollection", "form"); - } - var fileCollection_temp = fileCollection_raw; - global::Microsoft.AspNetCore.Http.IFormFileCollection fileCollection_local = fileCollection_temp!; - // Endpoint Parameter: collection (Type = Microsoft.AspNetCore.Http.IFormCollection, IsOptional = False, IsParsable = False, IsArray = False, Source = FormBody) - var collection_raw = httpContext.Request.Form; - if (collection_raw == null) - { - wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("IFormCollection", "collection", "form"); - } - var collection_temp = collection_raw; - global::Microsoft.AspNetCore.Http.IFormCollection collection_local = collection_temp!; - // Endpoint Parameter: tryParseRecord (Type = Microsoft.AspNetCore.Http.Generators.Tests.MyTryParseRecord, IsOptional = False, IsParsable = True, IsArray = False, Source = FormBody) - var tryParseRecord_raw = (string?)httpContext.Request.Form["tryParseRecord"]; - if (tryParseRecord_raw == null) + return; + } + var file_raw = httpContext.Request.Form.Files["file"]; + if (file_raw == null) + { + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("IFormFile", "file", "form"); + } + var file_temp = file_raw; + global::Microsoft.AspNetCore.Http.IFormFile file_local = file_temp!; + // Endpoint Parameter: fileCollection (Type = Microsoft.AspNetCore.Http.IFormFileCollection, IsOptional = False, IsParsable = False, IsArray = False, Source = FormBody) + var fileCollection_raw = httpContext.Request.Form.Files; + if (fileCollection_raw == null) + { + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("IFormFileCollection", "fileCollection", "form"); + } + var fileCollection_temp = fileCollection_raw; + global::Microsoft.AspNetCore.Http.IFormFileCollection fileCollection_local = fileCollection_temp!; + // Endpoint Parameter: collection (Type = Microsoft.AspNetCore.Http.IFormCollection, IsOptional = False, IsParsable = False, IsArray = False, Source = FormBody) + var collection_raw = httpContext.Request.Form; + if (collection_raw == null) + { + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("IFormCollection", "collection", "form"); + } + var collection_temp = collection_raw; + global::Microsoft.AspNetCore.Http.IFormCollection collection_local = collection_temp!; + // Endpoint Parameter: tryParseRecord (Type = Microsoft.AspNetCore.Http.Generators.Tests.MyTryParseRecord, IsOptional = False, IsParsable = True, IsArray = False, Source = FormBody) + var tryParseRecord_raw = (string?)httpContext.Request.Form["tryParseRecord"]; + if (tryParseRecord_raw == null) + { + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("MyTryParseRecord", "tryParseRecord", "form"); + } + var tryParseRecord_temp = tryParseRecord_raw; + if (!global::Microsoft.AspNetCore.Http.Generators.Tests.MyTryParseRecord.TryParse(tryParseRecord_temp!, out var tryParseRecord_parsed_temp)) + { + if (!string.IsNullOrEmpty(tryParseRecord_temp)) { + logOrThrowExceptionHelper.ParameterBindingFailed("MyTryParseRecord", "tryParseRecord", tryParseRecord_temp); wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("MyTryParseRecord", "tryParseRecord", "form"); } - var tryParseRecord_temp = tryParseRecord_raw; - if (!global::Microsoft.AspNetCore.Http.Generators.Tests.MyTryParseRecord.TryParse(tryParseRecord_temp!, out var tryParseRecord_parsed_temp)) - { - if (!string.IsNullOrEmpty(tryParseRecord_temp)) - { - logOrThrowExceptionHelper.ParameterBindingFailed("MyTryParseRecord", "tryParseRecord", tryParseRecord_temp); - wasParamCheckFailure = true; - } - } - global::Microsoft.AspNetCore.Http.Generators.Tests.MyTryParseRecord tryParseRecord_local = tryParseRecord_parsed_temp!; + } + global::Microsoft.AspNetCore.Http.Generators.Tests.MyTryParseRecord tryParseRecord_local = tryParseRecord_parsed_temp!; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, httpContext_local, file_local!, fileCollection_local!, collection_local!, tryParseRecord_local!)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, httpContext_local, file_local!, fileCollection_local!, collection_local!, tryParseRecord_local!)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + PostVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/VerifyAsParametersBaseline.generated.txt b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/VerifyAsParametersBaseline.generated.txt index 993bbb92b028..770e0ad0205f 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/VerifyAsParametersBaseline.generated.txt +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/Baselines/VerifyAsParametersBaseline.generated.txt @@ -22,97 +22,17 @@ namespace Microsoft.AspNetCore.Builder Line = line; } } +} - // This class needs to be internal so that the compiled application - // has access to the strongly-typed endpoint definitions that are - // generated by the compiler so that they will be favored by - // overload resolution and opt the runtime in to the code generated - // implementation produced here. +namespace System.Runtime.CompilerServices +{ %GENERATEDCODEATTRIBUTE% - internal static class GenerateRouteBuilderEndpoints + [AttributeUsage(AttributeTargets.Method)] + file sealed class InterceptsLocationAttribute : Attribute { - 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; - private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; - private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Action handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) + public InterceptsLocationAttribute(string filePath, int line, int column) { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); - } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Action handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) - { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); - } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Action handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) - { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapPost( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Func handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) - { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - PostVerb, - filePath, - lineNumber); - } - internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet( - this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, - [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, - global::System.Action handler, - [global::System.Runtime.CompilerServices.CallerFilePath] string filePath = "", - [global::System.Runtime.CompilerServices.CallerLineNumber]int lineNumber = 0) - { - return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( - endpoints, - pattern, - handler, - GetVerb, - filePath, - lineNumber); - } - } } @@ -148,490 +68,566 @@ 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[] PutVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Put }; + private static readonly string[] DeleteVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Delete }; + private static readonly string[] PatchVerb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.Patch }; - private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new() + [global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 44, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_44( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) { - [(@"TestMapActions.cs", 44)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 44)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 44)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, void (global::Microsoft.AspNetCore.Http.Generators.Tests.ParameterListWitDefaultValue arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Action)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - handler(ic.GetArgument(0)!); return ValueTask.FromResult(Results.Empty); - }, - options.EndpointBuilder, - handler.Method); - } + } + handler(ic.GetArgument(0)!); + return ValueTask.FromResult(Results.Empty); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: args (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParameterListWitDefaultValue, IsOptional = False, IsParsable = False, IsArray = False, Source = AsParameters) + var HttpContext_local = httpContext; + // Endpoint Parameter: Value (Type = int, IsOptional = True, IsParsable = True, IsArray = False, Source = Route) + if (options?.RouteParameterNames?.Contains("Value", StringComparer.OrdinalIgnoreCase) != true) { - var wasParamCheckFailure = false; - // Endpoint Parameter: args (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParameterListWitDefaultValue, IsOptional = False, IsParsable = False, IsArray = False, Source = AsParameters) - var HttpContext_local = httpContext; - // Endpoint Parameter: Value (Type = int, IsOptional = True, IsParsable = True, IsArray = False, Source = Route) - if (options?.RouteParameterNames?.Contains("Value", StringComparer.OrdinalIgnoreCase) != true) - { - throw new InvalidOperationException($"'Value' is not a route parameter."); - } - var Value_raw = (string?)httpContext.Request.RouteValues["Value"]; - var Value_temp = (string?)Value_raw; - int Value_parsed_temp = default; - if (GeneratedRouteBuilderExtensionsCore.TryParseExplicit(Value_temp!, CultureInfo.InvariantCulture, out var Value_temp_parsed_non_nullable)) - { - Value_parsed_temp = Value_temp_parsed_non_nullable; - } - else if (string.IsNullOrEmpty(Value_temp)) - { - Value_parsed_temp = 42; - } - else - { - wasParamCheckFailure = true; - } - int Value_local = Value_parsed_temp!; + throw new InvalidOperationException($"'Value' is not a route parameter."); + } + var Value_raw = (string?)httpContext.Request.RouteValues["Value"]; + var Value_temp = (string?)Value_raw; + int Value_parsed_temp = default; + if (GeneratedRouteBuilderExtensionsCore.TryParseExplicit(Value_temp!, CultureInfo.InvariantCulture, out var Value_temp_parsed_non_nullable)) + { + Value_parsed_temp = Value_temp_parsed_non_nullable; + } + else if (string.IsNullOrEmpty(Value_temp)) + { + Value_parsed_temp = 42; + } + else + { + wasParamCheckFailure = true; + } + int Value_local = Value_parsed_temp!; - var args_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParameterListWitDefaultValue(HttpContext_local, Value_local); + var args_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParameterListWitDefaultValue(HttpContext_local, Value_local); - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - handler(args_local); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; return Task.CompletedTask; } + handler(args_local); + return Task.CompletedTask; + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: args (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParameterListWitDefaultValue, IsOptional = False, IsParsable = False, IsArray = False, Source = AsParameters) + var HttpContext_local = httpContext; + // Endpoint Parameter: Value (Type = int, IsOptional = True, IsParsable = True, IsArray = False, Source = Route) + if (options?.RouteParameterNames?.Contains("Value", StringComparer.OrdinalIgnoreCase) != true) { - var wasParamCheckFailure = false; - // Endpoint Parameter: args (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParameterListWitDefaultValue, IsOptional = False, IsParsable = False, IsArray = False, Source = AsParameters) - var HttpContext_local = httpContext; - // Endpoint Parameter: Value (Type = int, IsOptional = True, IsParsable = True, IsArray = False, Source = Route) - if (options?.RouteParameterNames?.Contains("Value", StringComparer.OrdinalIgnoreCase) != true) - { - throw new InvalidOperationException($"'Value' is not a route parameter."); - } - var Value_raw = (string?)httpContext.Request.RouteValues["Value"]; - var Value_temp = (string?)Value_raw; - int Value_parsed_temp = default; - if (GeneratedRouteBuilderExtensionsCore.TryParseExplicit(Value_temp!, CultureInfo.InvariantCulture, out var Value_temp_parsed_non_nullable)) - { - Value_parsed_temp = Value_temp_parsed_non_nullable; - } - else if (string.IsNullOrEmpty(Value_temp)) - { - Value_parsed_temp = 42; - } - else - { - wasParamCheckFailure = true; - } - int Value_local = Value_parsed_temp!; + throw new InvalidOperationException($"'Value' is not a route parameter."); + } + var Value_raw = (string?)httpContext.Request.RouteValues["Value"]; + var Value_temp = (string?)Value_raw; + int Value_parsed_temp = default; + if (GeneratedRouteBuilderExtensionsCore.TryParseExplicit(Value_temp!, CultureInfo.InvariantCulture, out var Value_temp_parsed_non_nullable)) + { + Value_parsed_temp = Value_temp_parsed_non_nullable; + } + else if (string.IsNullOrEmpty(Value_temp)) + { + Value_parsed_temp = 42; + } + else + { + wasParamCheckFailure = true; + } + int Value_local = Value_parsed_temp!; - var args_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParameterListWitDefaultValue(HttpContext_local, Value_local); + var args_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParameterListWitDefaultValue(HttpContext_local, Value_local); - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, args_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, args_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 45)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 45)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } + +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 45, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_45( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 45)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, void (global::Microsoft.AspNetCore.Http.Generators.Tests.ParameterListRecordStruct arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var Value_RouteOrQueryResolver = GeneratedRouteBuilderExtensionsCore.ResolveFromRouteOrQuery("Value", options?.RouteParameterNames); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Action)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var Value_RouteOrQueryResolver = GeneratedRouteBuilderExtensionsCore.ResolveFromRouteOrQuery("Value", options?.RouteParameterNames); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - handler(ic.GetArgument(0)!); return ValueTask.FromResult(Results.Empty); - }, - options.EndpointBuilder, - handler.Method); - } + } + handler(ic.GetArgument(0)!); + return ValueTask.FromResult(Results.Empty); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: args (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParameterListRecordStruct, IsOptional = False, IsParsable = False, IsArray = False, Source = AsParameters) + var HttpContext_local = httpContext; + // Endpoint Parameter: Value (Type = int, IsOptional = False, IsParsable = True, IsArray = False, Source = RouteOrQuery) + var Value_raw = Value_RouteOrQueryResolver(httpContext); + if (Value_raw is StringValues { Count: 0 }) { - var wasParamCheckFailure = false; - // Endpoint Parameter: args (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParameterListRecordStruct, IsOptional = False, IsParsable = False, IsArray = False, Source = AsParameters) - var HttpContext_local = httpContext; - // Endpoint Parameter: Value (Type = int, IsOptional = False, IsParsable = True, IsArray = False, Source = RouteOrQuery) - var Value_raw = Value_RouteOrQueryResolver(httpContext); - if (Value_raw is StringValues { Count: 0 }) + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("int", "Value", "route or query string"); + } + var Value_temp = (string?)Value_raw; + if (!GeneratedRouteBuilderExtensionsCore.TryParseExplicit(Value_temp!, CultureInfo.InvariantCulture, out var Value_parsed_temp)) + { + if (!string.IsNullOrEmpty(Value_temp)) { + logOrThrowExceptionHelper.ParameterBindingFailed("int", "Value", Value_temp); wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("int", "Value", "route or query string"); } - var Value_temp = (string?)Value_raw; - if (!GeneratedRouteBuilderExtensionsCore.TryParseExplicit(Value_temp!, CultureInfo.InvariantCulture, out var Value_parsed_temp)) - { - if (!string.IsNullOrEmpty(Value_temp)) - { - logOrThrowExceptionHelper.ParameterBindingFailed("int", "Value", Value_temp); - wasParamCheckFailure = true; - } - } - int Value_local = Value_parsed_temp!; + } + int Value_local = Value_parsed_temp!; - var args_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParameterListRecordStruct { HttpContext = HttpContext_local, Value = Value_local }; + var args_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParameterListRecordStruct { HttpContext = HttpContext_local, Value = Value_local }; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - handler(args_local); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; return Task.CompletedTask; } + handler(args_local); + return Task.CompletedTask; + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: args (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParameterListRecordStruct, IsOptional = False, IsParsable = False, IsArray = False, Source = AsParameters) + var HttpContext_local = httpContext; + // Endpoint Parameter: Value (Type = int, IsOptional = False, IsParsable = True, IsArray = False, Source = RouteOrQuery) + var Value_raw = Value_RouteOrQueryResolver(httpContext); + if (Value_raw is StringValues { Count: 0 }) + { + wasParamCheckFailure = true; + logOrThrowExceptionHelper.RequiredParameterNotProvided("int", "Value", "route or query string"); + } + var Value_temp = (string?)Value_raw; + if (!GeneratedRouteBuilderExtensionsCore.TryParseExplicit(Value_temp!, CultureInfo.InvariantCulture, out var Value_parsed_temp)) { - var wasParamCheckFailure = false; - // Endpoint Parameter: args (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParameterListRecordStruct, IsOptional = False, IsParsable = False, IsArray = False, Source = AsParameters) - var HttpContext_local = httpContext; - // Endpoint Parameter: Value (Type = int, IsOptional = False, IsParsable = True, IsArray = False, Source = RouteOrQuery) - var Value_raw = Value_RouteOrQueryResolver(httpContext); - if (Value_raw is StringValues { Count: 0 }) + if (!string.IsNullOrEmpty(Value_temp)) { + logOrThrowExceptionHelper.ParameterBindingFailed("int", "Value", Value_temp); wasParamCheckFailure = true; - logOrThrowExceptionHelper.RequiredParameterNotProvided("int", "Value", "route or query string"); - } - var Value_temp = (string?)Value_raw; - if (!GeneratedRouteBuilderExtensionsCore.TryParseExplicit(Value_temp!, CultureInfo.InvariantCulture, out var Value_parsed_temp)) - { - if (!string.IsNullOrEmpty(Value_temp)) - { - logOrThrowExceptionHelper.ParameterBindingFailed("int", "Value", Value_temp); - wasParamCheckFailure = true; - } } - int Value_local = Value_parsed_temp!; + } + int Value_local = Value_parsed_temp!; - var args_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParameterListRecordStruct { HttpContext = HttpContext_local, Value = Value_local }; + var args_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParameterListRecordStruct { HttpContext = HttpContext_local, Value = Value_local }; - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, args_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, args_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 46)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 46)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } + +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 46, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_46( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 46)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, void (global::Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithHttpContext arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Action)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - handler(ic.GetArgument(0)!); return ValueTask.FromResult(Results.Empty); - }, - options.EndpointBuilder, - handler.Method); - } + } + handler(ic.GetArgument(0)!); + return ValueTask.FromResult(Results.Empty); + }, + options.EndpointBuilder, + handler.Method); + } - Task RequestHandler(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: args (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithHttpContext, IsOptional = False, IsParsable = False, IsArray = False, Source = AsParameters) - var HttpContext_local = httpContext; - var User_local = httpContext.User; - var Request_local = httpContext.Request; - var Response_local = httpContext.Response; + Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: args (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithHttpContext, IsOptional = False, IsParsable = False, IsArray = False, Source = AsParameters) + var HttpContext_local = httpContext; + var User_local = httpContext.User; + var Request_local = httpContext.Request; + var Response_local = httpContext.Response; - var args_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithHttpContext(HttpContext_local, User_local, Request_local, Response_local); + var args_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithHttpContext(HttpContext_local, User_local, Request_local, Response_local); - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return Task.CompletedTask; - } - handler(args_local); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; return Task.CompletedTask; } + handler(args_local); + return Task.CompletedTask; + } - async Task RequestHandlerFiltered(HttpContext httpContext) - { - var wasParamCheckFailure = false; - // Endpoint Parameter: args (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithHttpContext, IsOptional = False, IsParsable = False, IsArray = False, Source = AsParameters) - var HttpContext_local = httpContext; - var User_local = httpContext.User; - var Request_local = httpContext.Request; - var Response_local = httpContext.Response; + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: args (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithHttpContext, IsOptional = False, IsParsable = False, IsArray = False, Source = AsParameters) + var HttpContext_local = httpContext; + var User_local = httpContext.User; + var Request_local = httpContext.Request; + var Response_local = httpContext.Response; - var args_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithHttpContext(HttpContext_local, User_local, Request_local, Response_local); + var args_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithHttpContext(HttpContext_local, User_local, Request_local, Response_local); - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, args_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, args_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 47)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 47)); - options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(contentTypes: GeneratedMetadataConstants.JsonContentType)); - options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } + +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 47, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapPost_47( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 47)); + options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(contentTypes: GeneratedMetadataConstants.JsonContentType)); + options.EndpointBuilder.Metadata.Add(new GeneratedProducesResponseTypeMetadata(type: null, statusCode: StatusCodes.Status200OK, contentTypes: GeneratedMetadataConstants.PlaintextContentType)); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, global::System.String (global::Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithImplicitFromBody arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var serviceProviderIsService = serviceProvider?.GetService(); + var Todo_JsonBodyOrServiceResolver = ResolveJsonBodyOrService(logOrThrowExceptionHelper, "TodoStruct", "Todo", serviceProviderIsService); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Func)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var serviceProviderIsService = serviceProvider?.GetService(); - var Todo_JsonBodyOrServiceResolver = ResolveJsonBodyOrService(logOrThrowExceptionHelper, "TodoStruct", "Todo", serviceProviderIsService); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - return ValueTask.FromResult(handler(ic.GetArgument(0)!)); - }, - options.EndpointBuilder, - handler.Method); - } + return ValueTask.FromResult(Results.Empty); + } + return ValueTask.FromResult(handler(ic.GetArgument(0)!)); + }, + options.EndpointBuilder, + handler.Method); + } - async Task RequestHandler(HttpContext httpContext) + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: args (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithImplicitFromBody, IsOptional = False, IsParsable = False, IsArray = False, Source = AsParameters) + var HttpContext_local = httpContext; + // Endpoint Parameter: Todo (Type = Microsoft.AspNetCore.Http.Generators.Tests.TodoStruct, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBodyOrService) + var Todo_resolveJsonBodyOrServiceResult = await Todo_JsonBodyOrServiceResolver(httpContext, false); + var Todo_local = Todo_resolveJsonBodyOrServiceResult.Item2; + if (!Todo_resolveJsonBodyOrServiceResult.Item1) { - var wasParamCheckFailure = false; - // Endpoint Parameter: args (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithImplicitFromBody, IsOptional = False, IsParsable = False, IsArray = False, Source = AsParameters) - var HttpContext_local = httpContext; - // Endpoint Parameter: Todo (Type = Microsoft.AspNetCore.Http.Generators.Tests.TodoStruct, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBodyOrService) - var Todo_resolveJsonBodyOrServiceResult = await Todo_JsonBodyOrServiceResolver(httpContext, false); - var Todo_local = Todo_resolveJsonBodyOrServiceResult.Item2; - if (!Todo_resolveJsonBodyOrServiceResult.Item1) - { - return; - } + return; + } - var args_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithImplicitFromBody(HttpContext_local, Todo_local); + var args_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithImplicitFromBody(HttpContext_local, Todo_local); - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - httpContext.Response.ContentType ??= "text/plain"; - var result = handler(args_local); - await httpContext.Response.WriteAsync(result); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return; } + httpContext.Response.ContentType ??= "text/plain"; + var result = handler(args_local); + await httpContext.Response.WriteAsync(result); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: args (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithImplicitFromBody, IsOptional = False, IsParsable = False, IsArray = False, Source = AsParameters) + var HttpContext_local = httpContext; + // Endpoint Parameter: Todo (Type = Microsoft.AspNetCore.Http.Generators.Tests.TodoStruct, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBodyOrService) + var Todo_resolveJsonBodyOrServiceResult = await Todo_JsonBodyOrServiceResolver(httpContext, false); + var Todo_local = Todo_resolveJsonBodyOrServiceResult.Item2; + if (!Todo_resolveJsonBodyOrServiceResult.Item1) { - var wasParamCheckFailure = false; - // Endpoint Parameter: args (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithImplicitFromBody, IsOptional = False, IsParsable = False, IsArray = False, Source = AsParameters) - var HttpContext_local = httpContext; - // Endpoint Parameter: Todo (Type = Microsoft.AspNetCore.Http.Generators.Tests.TodoStruct, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBodyOrService) - var Todo_resolveJsonBodyOrServiceResult = await Todo_JsonBodyOrServiceResolver(httpContext, false); - var Todo_local = Todo_resolveJsonBodyOrServiceResult.Item2; - if (!Todo_resolveJsonBodyOrServiceResult.Item1) - { - return; - } + return; + } - var args_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithImplicitFromBody(HttpContext_local, Todo_local); + var args_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithImplicitFromBody(HttpContext_local, Todo_local); - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, args_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, args_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - [(@"TestMapActions.cs", 48)] = ( - (methodInfo, options) => - { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 48)); - options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(contentTypes: GeneratedMetadataConstants.JsonContentType)); - var parameterInfos = methodInfo.GetParameters(); - var Value_ParameterInfo = new PropertyAsParameterInfo(false, typeof(Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithMetadataType)!.GetProperty("Value")!, typeof(Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithMetadataType).GetConstructor(new[] { typeof(Microsoft.AspNetCore.Http.HttpContext), typeof(Microsoft.AspNetCore.Http.Generators.Tests.AddsCustomParameterMetadataAsProperty) })?.GetParameters()[1]); - PopulateMetadataForParameter(Value_ParameterInfo, options.EndpointBuilder); - PopulateMetadataForEndpoint(methodInfo, options.EndpointBuilder); - return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; - }, - (del, options, inferredMetadataResult) => + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + PostVerb, + populateMetadata, + createRequestDelegate); + } + +[global::System.Runtime.CompilerServices.InterceptsLocation(@"TestMapActions.cs", 48, 5)] + internal static global::Microsoft.AspNetCore.Builder.RouteHandlerBuilder MapGet_48( + this global::Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, + [global::System.Diagnostics.CodeAnalysis.StringSyntax("Route")] string pattern, + global::System.Delegate handler) + { + MetadataPopulator populateMetadata = (methodInfo, options) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + options.EndpointBuilder.Metadata.Add(new SourceKey(@"TestMapActions.cs", 48)); + options.EndpointBuilder.Metadata.Add(new GeneratedAcceptsMetadata(contentTypes: GeneratedMetadataConstants.JsonContentType)); + var parameterInfos = methodInfo.GetParameters(); + var Value_ParameterInfo = new PropertyAsParameterInfo(false, typeof(Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithMetadataType)!.GetProperty("Value")!, typeof(Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithMetadataType).GetConstructor(new[] { typeof(Microsoft.AspNetCore.Http.HttpContext), typeof(Microsoft.AspNetCore.Http.Generators.Tests.AddsCustomParameterMetadataAsProperty) })?.GetParameters()[1]); + PopulateMetadataForParameter(Value_ParameterInfo, options.EndpointBuilder); + PopulateMetadataForEndpoint(methodInfo, options.EndpointBuilder); + return new RequestDelegateMetadataResult { EndpointMetadata = options.EndpointBuilder.Metadata.AsReadOnly() }; + }; + RequestDelegateFactoryFunc createRequestDelegate = (del, options, inferredMetadataResult) => + { + Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); + Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); + var handler = Cast(del, void (global::Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithMetadataType arg0) => throw null!); + EndpointFilterDelegate? filteredInvocation = null; + var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; + var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); + var serviceProviderIsService = serviceProvider?.GetService(); + var Value_JsonBodyOrServiceResolver = ResolveJsonBodyOrService(logOrThrowExceptionHelper, "AddsCustomParameterMetadataAsProperty", "Value", serviceProviderIsService); + + if (options?.EndpointBuilder?.FilterFactories.Count > 0) { - Debug.Assert(options != null, "RequestDelegateFactoryOptions not found."); - Debug.Assert(options.EndpointBuilder != null, "EndpointBuilder not found."); - var handler = (System.Action)del; - EndpointFilterDelegate? filteredInvocation = null; - var serviceProvider = options.ServiceProvider ?? options.EndpointBuilder.ApplicationServices; - var logOrThrowExceptionHelper = new LogOrThrowExceptionHelper(serviceProvider, options); - var serviceProviderIsService = serviceProvider?.GetService(); - var Value_JsonBodyOrServiceResolver = ResolveJsonBodyOrService(logOrThrowExceptionHelper, "AddsCustomParameterMetadataAsProperty", "Value", serviceProviderIsService); - - if (options?.EndpointBuilder?.FilterFactories.Count > 0) + filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => { - filteredInvocation = GeneratedRouteBuilderExtensionsCore.BuildFilterDelegate(ic => + if (ic.HttpContext.Response.StatusCode == 400) { - if (ic.HttpContext.Response.StatusCode == 400) - { - return ValueTask.FromResult(Results.Empty); - } - handler(ic.GetArgument(0)!); return ValueTask.FromResult(Results.Empty); - }, - options.EndpointBuilder, - handler.Method); - } + } + handler(ic.GetArgument(0)!); + return ValueTask.FromResult(Results.Empty); + }, + options.EndpointBuilder, + handler.Method); + } - async Task RequestHandler(HttpContext httpContext) + async Task RequestHandler(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: args (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithMetadataType, IsOptional = False, IsParsable = False, IsArray = False, Source = AsParameters) + var HttpContext_local = httpContext; + // Endpoint Parameter: Value (Type = Microsoft.AspNetCore.Http.Generators.Tests.AddsCustomParameterMetadataAsProperty, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBodyOrService) + var Value_resolveJsonBodyOrServiceResult = await Value_JsonBodyOrServiceResolver(httpContext, false); + var Value_local = Value_resolveJsonBodyOrServiceResult.Item2; + if (!Value_resolveJsonBodyOrServiceResult.Item1) { - var wasParamCheckFailure = false; - // Endpoint Parameter: args (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithMetadataType, IsOptional = False, IsParsable = False, IsArray = False, Source = AsParameters) - var HttpContext_local = httpContext; - // Endpoint Parameter: Value (Type = Microsoft.AspNetCore.Http.Generators.Tests.AddsCustomParameterMetadataAsProperty, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBodyOrService) - var Value_resolveJsonBodyOrServiceResult = await Value_JsonBodyOrServiceResolver(httpContext, false); - var Value_local = Value_resolveJsonBodyOrServiceResult.Item2; - if (!Value_resolveJsonBodyOrServiceResult.Item1) - { - return; - } + return; + } - var args_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithMetadataType(HttpContext_local, Value_local); + var args_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithMetadataType(HttpContext_local, Value_local); - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - return; - } - handler(args_local); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; + return; } + handler(args_local); + } - async Task RequestHandlerFiltered(HttpContext httpContext) + async Task RequestHandlerFiltered(HttpContext httpContext) + { + var wasParamCheckFailure = false; + // Endpoint Parameter: args (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithMetadataType, IsOptional = False, IsParsable = False, IsArray = False, Source = AsParameters) + var HttpContext_local = httpContext; + // Endpoint Parameter: Value (Type = Microsoft.AspNetCore.Http.Generators.Tests.AddsCustomParameterMetadataAsProperty, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBodyOrService) + var Value_resolveJsonBodyOrServiceResult = await Value_JsonBodyOrServiceResolver(httpContext, false); + var Value_local = Value_resolveJsonBodyOrServiceResult.Item2; + if (!Value_resolveJsonBodyOrServiceResult.Item1) { - var wasParamCheckFailure = false; - // Endpoint Parameter: args (Type = Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithMetadataType, IsOptional = False, IsParsable = False, IsArray = False, Source = AsParameters) - var HttpContext_local = httpContext; - // Endpoint Parameter: Value (Type = Microsoft.AspNetCore.Http.Generators.Tests.AddsCustomParameterMetadataAsProperty, IsOptional = False, IsParsable = False, IsArray = False, Source = JsonBodyOrService) - var Value_resolveJsonBodyOrServiceResult = await Value_JsonBodyOrServiceResolver(httpContext, false); - var Value_local = Value_resolveJsonBodyOrServiceResult.Item2; - if (!Value_resolveJsonBodyOrServiceResult.Item1) - { - return; - } + return; + } - var args_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithMetadataType(HttpContext_local, Value_local); + var args_local = new global::Microsoft.AspNetCore.Http.Generators.Tests.ParametersListWithMetadataType(HttpContext_local, Value_local); - if (wasParamCheckFailure) - { - httpContext.Response.StatusCode = 400; - } - var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, args_local)); - await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + if (wasParamCheckFailure) + { + httpContext.Response.StatusCode = 400; } + var result = await filteredInvocation(EndpointFilterInvocationContext.Create(httpContext, args_local)); + await GeneratedRouteBuilderExtensionsCore.ExecuteObjectResult(result, httpContext); + } + + RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; + var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; + return new RequestDelegateResult(targetDelegate, metadata); + }; + return global::Microsoft.AspNetCore.Http.Generated.GeneratedRouteBuilderExtensionsCore.MapCore( + endpoints, + pattern, + handler, + GetVerb, + populateMetadata, + createRequestDelegate); + } - RequestDelegate targetDelegate = filteredInvocation is null ? RequestHandler : RequestHandlerFiltered; - var metadata = inferredMetadataResult?.EndpointMetadata ?? ReadOnlyCollection.Empty; - return new RequestDelegateResult(targetDelegate, metadata); - }), - }; internal static RouteHandlerBuilder MapCore( this IEndpointRouteBuilder routes, string pattern, Delegate handler, IEnumerable? httpMethods, - string filePath, - int lineNumber) + MetadataPopulator populateMetadata, + RequestDelegateFactoryFunc createRequestDelegate) { - var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)]; return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate); } + private static T Cast(Delegate d, T _) where T : Delegate + { + return (T)d; + } + private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi) { var routeHandlerFilters = builder.FilterFactories; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/CompileTimeCreationTests.cs b/src/Http/Http.Extensions/test/RequestDelegateGenerator/CompileTimeCreationTests.cs index a1d28b26c124..37d90ef095b4 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/CompileTimeCreationTests.cs +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/CompileTimeCreationTests.cs @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. using Microsoft.CodeAnalysis; using Microsoft.AspNetCore.Http.RequestDelegateGenerator; +using Microsoft.Extensions.Primitives; namespace Microsoft.AspNetCore.Http.Generators.Tests; @@ -80,4 +81,28 @@ public async Task MapAction_WarnsForUnsupportedRouteVariable() await endpoint.RequestDelegate(httpContext); await VerifyResponseBodyAsync(httpContext, "Hello world!"); } + + [Fact] + public async Task MapAction_SupportsParametersWithDifferingNullability() + { + var source = """ +app.MapGet("/hello", (string name) => $"Hello {name}!"); +app.MapGet("/hello2", (string? name) => $"Hello {name ?? string.Empty}!"); +"""; + var (result, compilation) = await RunGeneratorAsync(source); + var endpoints = GetEndpointsFromCompilation(compilation); + + foreach (var endpoint in endpoints) + { + var httpContext = CreateHttpContext(); + httpContext.Request.Query = new QueryCollection(new Dictionary() + { + { + "name", "world" + } + }); + await endpoint.RequestDelegate(httpContext); + await VerifyResponseBodyAsync(httpContext, "Hello world!"); + } + } } diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTestBase.cs b/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTestBase.cs index 509c782b24b3..6c2da6f9b13f 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTestBase.cs +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTestBase.cs @@ -28,7 +28,7 @@ namespace Microsoft.AspNetCore.Http.Generators.Tests; public abstract class RequestDelegateCreationTestBase : LoggedTest { // Change this to true and run tests in development to regenerate baseline files. - public bool RegenerateBaselines => false; + public bool RegenerateBaselines => true; protected abstract bool IsGeneratorEnabled { get; } @@ -36,8 +36,6 @@ public abstract class RequestDelegateCreationTestBase : LoggedTest internal async Task<(GeneratorRunResult?, Compilation)> RunGeneratorAsync(string sources, params string[] updatedSources) { - var source = GetMapActionString(sources); - var project = _baseProject.AddDocument("TestMapActions.cs", SourceText.From(source, Encoding.UTF8)).Project; // Create a Roslyn compilation for the syntax tree. var compilation = await CreateCompilationAsync(sources); @@ -56,12 +54,13 @@ public abstract class RequestDelegateCreationTestBase : LoggedTest { generator }, - driverOptions: new GeneratorDriverOptions(IncrementalGeneratorOutputKind.None, trackIncrementalGeneratorSteps: true)); + driverOptions: new GeneratorDriverOptions(IncrementalGeneratorOutputKind.None, trackIncrementalGeneratorSteps: true), + parseOptions: new CSharpParseOptions(LanguageVersion.Preview)); driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out var updatedCompilation, out var _); foreach (var updatedSource in updatedSources) { - var syntaxTree = CSharpSyntaxTree.ParseText(GetMapActionString(updatedSource), path: $"TestMapActions.cs"); + var syntaxTree = CSharpSyntaxTree.ParseText(GetMapActionString(updatedSource), path: $"TestMapActions.cs", options: new CSharpParseOptions(LanguageVersion.Preview)); compilation = compilation .ReplaceSyntaxTree(compilation.SyntaxTrees.First(), syntaxTree); driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out updatedCompilation, @@ -74,24 +73,24 @@ public abstract class RequestDelegateCreationTestBase : LoggedTest return (Assert.Single(runResult.Results), updatedCompilation); } - internal static RequestDelegateGenerator.StaticRouteHandlerModel.Endpoint GetStaticEndpoint(GeneratorRunResult result, string stepName) => + internal static RequestDelegateGenerator.StaticRouteHandler.Model.Endpoint GetStaticEndpoint(GeneratorRunResult result, string stepName) => Assert.Single(GetStaticEndpoints(result, stepName)); - internal static RequestDelegateGenerator.StaticRouteHandlerModel.Endpoint[] GetStaticEndpoints(GeneratorRunResult result, string stepName) + internal static RequestDelegateGenerator.StaticRouteHandler.Model.Endpoint[] GetStaticEndpoints(GeneratorRunResult result, string stepName) { // We only invoke the generator once in our test scenarios if (result.TrackedSteps.TryGetValue(stepName, out var staticEndpointSteps)) { return staticEndpointSteps .SelectMany(step => step.Outputs) - .Select(output => Assert.IsType(output.Value)) + .Select(output => Assert.IsType(output.Value)) .ToArray(); } - return Array.Empty(); + return Array.Empty(); } - internal static void VerifyStaticEndpointModel(GeneratorRunResult? result, Action runAssertions) + internal static void VerifyStaticEndpointModel(GeneratorRunResult? result, Action runAssertions) { if (result.HasValue) { @@ -99,7 +98,7 @@ internal static void VerifyStaticEndpointModel(GeneratorRunResult? result, Actio } } - internal static void VerifyStaticEndpointModels(GeneratorRunResult? result, Action runAssertions) + internal static void VerifyStaticEndpointModels(GeneratorRunResult? result, Action runAssertions) { if (result.HasValue) { @@ -135,7 +134,7 @@ internal Endpoint[] GetEndpointsFromCompilation(Compilation compilation, bool? e var sourceText = SourceText.From(buffer, buffer.Length, encoding, canBeEmbedded: true); var syntaxRootNode = (CSharpSyntaxNode)syntaxTree.GetRoot(); - var newSyntaxTree = CSharpSyntaxTree.Create(syntaxRootNode, options: null, encoding: encoding, path: syntaxTree.FilePath); + var newSyntaxTree = CSharpSyntaxTree.Create(syntaxRootNode, options: new CSharpParseOptions(LanguageVersion.Preview), encoding: encoding, path: syntaxTree.FilePath); compilation = compilation.ReplaceSyntaxTree(syntaxTree, newSyntaxTree); @@ -275,7 +274,7 @@ private static Project CreateProject() .AddProject(projectName, projectName, LanguageNames.CSharp) .WithCompilationOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary) .WithNullableContextOptions(NullableContextOptions.Enable)) - .WithParseOptions(new CSharpParseOptions(LanguageVersion.CSharp11)); + .WithParseOptions(new CSharpParseOptions(LanguageVersion.Preview)); // Add in required metadata references var resolver = new AppLocalResolver(); @@ -321,7 +320,7 @@ internal async Task VerifyAgainstBaselineUsingFile(Compilation compilation, [Cal .Replace(RequestDelegateGeneratorSources.GeneratedCodeAttribute, "%GENERATEDCODEATTRIBUTE%") + Environment.NewLine; await File.WriteAllTextAsync(baselineFilePath, newSource); - Assert.Fail("RegenerateBaselines=true. Do not merge PRs with this set."); + // Assert.Fail("RegenerateBaselines=true. Do not merge PRs with this set."); } var baseline = await File.ReadAllTextAsync(baselineFilePath); diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.Arrays.cs b/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.Arrays.cs index 53544c515936..2b8db795499e 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.Arrays.cs +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.Arrays.cs @@ -9,7 +9,7 @@ using System.Text.Encodings.Web; using System.Text.Json; using Microsoft.AspNetCore.Http.Features; -using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel; +using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Model; using Microsoft.Extensions.Primitives; using Microsoft.VisualStudio.TestPlatform.Common; using Microsoft.VisualStudio.TestPlatform.ObjectModel.Client; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.BindAsync.cs b/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.BindAsync.cs index c63979916189..0b7b94395754 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.BindAsync.cs +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.BindAsync.cs @@ -11,7 +11,7 @@ using System.Text.Encodings.Web; using System.Text.Json; using Microsoft.AspNetCore.Http.Features; -using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel; +using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Model; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Primitives; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.Metadata.cs b/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.Metadata.cs index dae0f0581d0e..432b5bfb2855 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.Metadata.cs +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.Metadata.cs @@ -10,7 +10,7 @@ using System.Text.Encodings.Web; using Microsoft.AspNetCore.Http.Features; using Microsoft.AspNetCore.Http.Metadata; -using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel; +using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Model; using Microsoft.AspNetCore.Routing.Patterns; using Microsoft.AspNetCore.Routing; using Microsoft.Extensions.DependencyInjection; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.QueryParameters.cs b/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.QueryParameters.cs index 3e1ace1dbfe2..1a52dee8ac72 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.QueryParameters.cs +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.QueryParameters.cs @@ -2,7 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. using System.Text; -using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel; +using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Model; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Primitives; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.TryParse.cs b/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.TryParse.cs index 058743be6f24..f9ec8e5ae40b 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.TryParse.cs +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.TryParse.cs @@ -6,8 +6,7 @@ using System.Reflection; using System.Reflection.Metadata; using System.Text.Encodings.Web; -using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel; -using Microsoft.Extensions.Primitives; +using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Model; namespace Microsoft.AspNetCore.Http.Generators.Tests; diff --git a/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.cs b/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.cs index 8588ec2198dc..2bc45576faaf 100644 --- a/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.cs +++ b/src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.cs @@ -1,17 +1,7 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System.Globalization; -using System.Net; -using System.Net.Sockets; -using System.Numerics; -using System.Reflection; -using System.Reflection.Metadata; -using System.Text; -using System.Text.Encodings.Web; -using System.Text.Json; -using Microsoft.AspNetCore.Http.Features; -using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel; +using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandler.Model; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Primitives; diff --git a/src/Shared/RoslynUtils/CodeWriter.cs b/src/Shared/RoslynUtils/CodeWriter.cs index 079aad0085dd..eff1aa12a9c1 100644 --- a/src/Shared/RoslynUtils/CodeWriter.cs +++ b/src/Shared/RoslynUtils/CodeWriter.cs @@ -30,6 +30,12 @@ public void EndBlockWithComma() this.WriteLine("},"); } + public void EndBlockWithSemicolon() + { + this.Indent--; + this.WriteLine("};"); + } + // The IndentedTextWriter adds the indentation // _after_ writing the first line of text. This // method can be used ot initialize indentation