Surrogate argument list in Minimal APIs

src/Http/Http.Extensions/src/ParametersAttribute.cs

@@ -0,0 +1,14 @@
+// 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;
+
+using System;
+
+/// <summary>
+/// 
+/// </summary>
+[AttributeUsage(AttributeTargets.Parameter, Inherited = false, AllowMultiple = false)]
+public sealed class ParametersAttribute : Attribute
+{
+}

src/Http/Http.Extensions/src/PublicAPI.Unshipped.txt

@@ -13,6 +13,8 @@ Microsoft.AspNetCore.Http.Metadata.IEndpointMetadataProvider
 Microsoft.AspNetCore.Http.Metadata.IEndpointMetadataProvider.PopulateMetadata(Microsoft.AspNetCore.Http.Metadata.EndpointMetadataContext! context) -> void
 Microsoft.AspNetCore.Http.Metadata.IEndpointParameterMetadataProvider
 Microsoft.AspNetCore.Http.Metadata.IEndpointParameterMetadataProvider.PopulateMetadata(Microsoft.AspNetCore.Http.Metadata.EndpointParameterMetadataContext! parameterContext) -> void
+Microsoft.AspNetCore.Http.ParametersAttribute
+Microsoft.AspNetCore.Http.ParametersAttribute.ParametersAttribute() -> void
 Microsoft.AspNetCore.Http.RequestDelegateFactoryOptions.InitialEndpointMetadata.get -> System.Collections.Generic.IEnumerable<object!>?
 Microsoft.AspNetCore.Http.RequestDelegateFactoryOptions.InitialEndpointMetadata.init -> void
 Microsoft.AspNetCore.Http.RequestDelegateFactoryOptions.RouteHandlerFilterFactories.get -> System.Collections.Generic.IReadOnlyList<System.Func<Microsoft.AspNetCore.Http.RouteHandlerContext!, Microsoft.AspNetCore.Http.RouteHandlerFilterDelegate!, Microsoft.AspNetCore.Http.RouteHandlerFilterDelegate!>!>?

src/Http/Http.Extensions/src/RequestDelegateFactory.cs

@@ -214,7 +214,10 @@ private static FactoryContext CreateFactoryContext(RequestDelegateFactoryOptions
         factoryContext.MethodCall = CreateMethodCall(methodInfo, targetExpression, arguments);
 
         // Add metadata provided by the delegate return type and parameter types next, this will be more specific than inferred metadata from above
-        AddTypeProvidedMetadata(methodInfo, factoryContext.Metadata, factoryContext.ServiceProvider);
+        AddTypeProvidedMetadata(methodInfo,
+            factoryContext.Metadata,
+            factoryContext.ServiceProvider,
+            factoryContext.SurrogatedParameters.ToArray());
 
         // Add method attributes as metadata *after* any inferred metadata so that the attributes hava a higher specificity
         AddMethodAttributesAsMetadata(methodInfo, factoryContext.Metadata);
@@ -283,33 +286,40 @@ private static RouteHandlerFilterDelegate CreateFilterPipeline(MethodInfo method
         return filteredInvocation;
     }
 
-    private static void AddTypeProvidedMetadata(MethodInfo methodInfo, List<object> metadata, IServiceProvider? services)
+    private static void AddTypeProvidedMetadata(MethodInfo methodInfo, List<object> metadata, IServiceProvider? services, ParameterInfo[] surrogatedParameters)
     {
         object?[]? invokeArgs = null;
 
-        // Get metadata from parameter types
-        var parameters = methodInfo.GetParameters();
-        foreach (var parameter in parameters)
+        void AddMetadata(ParameterInfo[] parameters)
         {
-            if (typeof(IEndpointParameterMetadataProvider).IsAssignableFrom(parameter.ParameterType))
+            foreach (var parameter in parameters)
             {
-                // Parameter type implements IEndpointParameterMetadataProvider
-                var parameterContext = new EndpointParameterMetadataContext(parameter, metadata, services);
-                invokeArgs ??= new object[1];
-                invokeArgs[0] = parameterContext;
-                PopulateMetadataForParameterMethod.MakeGenericMethod(parameter.ParameterType).Invoke(null, invokeArgs);
-            }
+                if (typeof(IEndpointParameterMetadataProvider).IsAssignableFrom(parameter.ParameterType))
+                {
+                    // Parameter type implements IEndpointParameterMetadataProvider
+                    var parameterContext = new EndpointParameterMetadataContext(parameter, metadata, services);
+                    invokeArgs ??= new object[1];
+                    invokeArgs[0] = parameterContext;
+                    PopulateMetadataForParameterMethod.MakeGenericMethod(parameter.ParameterType).Invoke(null, invokeArgs);
+                }
 
-            if (typeof(IEndpointMetadataProvider).IsAssignableFrom(parameter.ParameterType))
-            {
-                // Parameter type implements IEndpointMetadataProvider
-                var context = new EndpointMetadataContext(methodInfo, metadata, services);
-                invokeArgs ??= new object[1];
-                invokeArgs[0] = context;
-                PopulateMetadataForEndpointMethod.MakeGenericMethod(parameter.ParameterType).Invoke(null, invokeArgs);
+                if (typeof(IEndpointMetadataProvider).IsAssignableFrom(parameter.ParameterType))
+                {
+                    // Parameter type implements IEndpointMetadataProvider
+                    var context = new EndpointMetadataContext(methodInfo, metadata, services);
+                    invokeArgs ??= new object[1];
+                    invokeArgs[0] = context;
+                    PopulateMetadataForEndpointMethod.MakeGenericMethod(parameter.ParameterType).Invoke(null, invokeArgs);
+                }
             }
         }
 
+        // Get metadata from parameter types
+        AddMetadata(methodInfo.GetParameters());
+
+        // Get metadata from surrogated parameter types
+        AddMetadata(surrogatedParameters);
+
         // Get metadata from return type
         if (methodInfo.ReturnType is not null && typeof(IEndpointMetadataProvider).IsAssignableFrom(methodInfo.ReturnType))
         {
@@ -391,14 +401,19 @@ private static Expression[] CreateArguments(ParameterInfo[]? parameters, Factory
 
     private static Expression CreateArgument(ParameterInfo parameter, FactoryContext factoryContext)
     {
+        var parameterCustomAttributes = parameter.GetCustomAttributes();
+
         if (parameter.Name is null)
         {
             throw new InvalidOperationException($"Encountered a parameter of type '{parameter.ParameterType}' without a name. Parameters must have a name.");
         }
 
-        var parameterCustomAttributes = parameter.GetCustomAttributes();
-
-        if (parameterCustomAttributes.OfType<IFromRouteMetadata>().FirstOrDefault() is { } routeAttribute)
+        if (parameterCustomAttributes.OfType<ParametersAttribute>().FirstOrDefault() is { } ||
+            parameter.ParameterType.GetCustomAttributes().OfType<ParametersAttribute>().FirstOrDefault() is { })
+        {
+            return BindSurrogatedArgument(parameter, factoryContext);
+        }
+        else if (parameterCustomAttributes.OfType<IFromRouteMetadata>().FirstOrDefault() is { } routeAttribute)
         {
             var routeName = routeAttribute.Name ?? parameter.Name;
             factoryContext.TrackedParameters.Add(parameter.Name, RequestDelegateFactoryConstants.RouteAttribute);
@@ -1070,6 +1085,90 @@ private static Expression GetValueFromProperty(Expression sourceExpression, stri
         return Expression.Convert(indexExpression, returnType ?? typeof(string));
     }
 
+    private static Expression BindSurrogatedArgument(ParameterInfo parameter, FactoryContext factoryContext)
+    {
+        var properties = parameter.ParameterType.GetProperties();
+        var argumentExpression = Expression.Variable(parameter.ParameterType, $"{parameter.Name}_local");
+
+        static ConstructorInfo? GetConstructor(ParameterInfo parameter, PropertyInfo[] properties)
+        {
+            if (parameter.ParameterType.IsValueType)
+            {
+                // Value types always have a default constructor, we will use
+                // the parameter type during the NewExpression creation
+                return null;
+            }
+
+            // Try to find the parameterless constructor
+            var constructor = parameter.ParameterType.GetConstructor(Array.Empty<Type>());
+            if (constructor is { })
+            {
+                return constructor;
+            }
+
+            // If a parameterless ctor is not defined
+            // we will try to find a ctor that includes all the property types.
+            var types = new Type[properties.Length];
+            for (var i = 0; i < properties.Length; i++)
+            {
+                types[i] = properties[i].PropertyType;
+            }
+            constructor = parameter.ParameterType.GetConstructor(types);
+
+            if (constructor is { })
+            {
+                return constructor;
+            }
+
+            throw new InvalidOperationException($"No '{parameter.ParameterType}' public parameterless constructor found for {parameter.Name}.");
+        }
+
+        var constructor = GetConstructor(parameter, properties);
+        if (constructor?.GetParameters() is { Length: > 0 } parameters)
+        {
+            //  arg_local = new T(....)
+            var constructorArguments = new Expression[properties.Length];
+
+            for (var i = 0; i < properties.Length; i++)
+            {
+                var parameterInfo = new SurrogatedParameterInfo(properties[i], factoryContext);
+                constructorArguments[i] = CreateArgument(parameterInfo, factoryContext);
+                factoryContext.SurrogatedParameters.Add(parameterInfo);
+            }
+
+            factoryContext.ParamCheckExpressions.Add(Expression.Assign(argumentExpression, Expression.New(constructor, constructorArguments)));
+        }
+        else
+        {
+            //  arg_local = new T()
+            //  {
+            //      arg_local.Property[0] = expression[0],
+            //      arg_local.Property[n] = expression[n],
+            //  }
+
+            var bindings = new List<MemberBinding>(properties.Length);
+
+            for (var i = 0; i < properties.Length; i++)
+            {
+                // For parameterless ctor we will init only writable properties.
+                if (properties[i].CanWrite)
+                {
+                    var parameterInfo = new SurrogatedParameterInfo(properties[i], factoryContext);
+                    bindings.Add(Expression.Bind(properties[i], CreateArgument(parameterInfo, factoryContext)));
+                    factoryContext.SurrogatedParameters.Add(parameterInfo);
+                }
+            }
+
+            var newExpression = constructor is null ? Expression.New(parameter.ParameterType) : Expression.New(constructor);
+            factoryContext.ParamCheckExpressions.Add(Expression.Assign(argumentExpression, Expression.MemberInit(newExpression, bindings)));
+        }
+
+        factoryContext.TrackedParameters.Add(parameter.Name!, RequestDelegateFactoryConstants.SurrogatedParameter);
+        factoryContext.ExtraLocals.Add(argumentExpression);
+
+        return argumentExpression;
+    }
+
     private static Expression BindParameterFromService(ParameterInfo parameter, FactoryContext factoryContext)
     {
         var isOptional = IsOptionalParameter(parameter, factoryContext);
@@ -1560,15 +1659,20 @@ private static Expression BindParameterFromBody(ParameterInfo parameter, bool al
 
     private static bool IsOptionalParameter(ParameterInfo parameter, FactoryContext factoryContext)
     {
+        if (parameter is SurrogatedParameterInfo argument)
+        {
+            return argument.IsOptional;
+        }
+
         // - Parameters representing value or reference types with a default value
         // under any nullability context are treated as optional.
         // - Value type parameters without a default value in an oblivious
         // nullability context are required.
         // - Reference type parameters without a default value in an oblivious
         // nullability context are optional.
-        var nullability = factoryContext.NullabilityContext.Create(parameter);
+        var nullabilityInfo = factoryContext.NullabilityContext.Create(parameter);
         return parameter.HasDefaultValue
-            || nullability.ReadState != NullabilityState.NotNull;
+            || nullabilityInfo.ReadState != NullabilityState.NotNull;
     }
 
     private static MethodInfo GetMethodInfo<T>(Expression<T> expr)
@@ -1792,6 +1896,8 @@ private class FactoryContext
         public Expression? MethodCall { get; set; }
         public List<Expression> BoxedArgs { get; } = new();
         public List<Func<RouteHandlerContext, RouteHandlerFilterDelegate, RouteHandlerFilterDelegate>>? Filters { get; init; }
+
+        public List<ParameterInfo> SurrogatedParameters { get; } = new();
     }
 
     private static class RequestDelegateFactoryConstants
@@ -1808,6 +1914,52 @@ private static class RequestDelegateFactoryConstants
         public const string BodyParameter = "Body (Inferred)";
         public const string RouteOrQueryStringParameter = "Route or Query String (Inferred)";
         public const string FormFileParameter = "Form File (Inferred)";
+        public const string SurrogatedParameter = "Surrogate (Attribute)";
+    }
+
+    private class SurrogatedParameterInfo : ParameterInfo
+    {
+        private readonly PropertyInfo _underlyingProperty;
+        private readonly NullabilityInfo _nullabilityInfo;
+
+        public SurrogatedParameterInfo(PropertyInfo propertyInfo, FactoryContext factoryContext)
+        {
+            Debug.Assert(null != propertyInfo);
+
+            AttrsImpl = (ParameterAttributes)propertyInfo.Attributes;
+            MemberImpl = propertyInfo;
+            NameImpl = propertyInfo.Name;
+            ClassImpl = propertyInfo.PropertyType;
+            PositionImpl = -1;//parameter.Position;
+
+            _nullabilityInfo = factoryContext.NullabilityContext.Create(propertyInfo);
+            _underlyingProperty = propertyInfo;
+        }
+
+        public override bool HasDefaultValue => false;
+        public override object? DefaultValue => null;
+        public override int MetadataToken => _underlyingProperty.MetadataToken;
+        public override object? RawDefaultValue => null;
+
+        public override object[] GetCustomAttributes(Type attributeType, bool inherit)
+            => _underlyingProperty.GetCustomAttributes(attributeType, inherit);
+
+        public override object[] GetCustomAttributes(bool inherit)
+            => _underlyingProperty.GetCustomAttributes(inherit);
+
+        public override IList<CustomAttributeData> GetCustomAttributesData()
+            => _underlyingProperty.GetCustomAttributesData();
+
+        public override Type[] GetOptionalCustomModifiers()
+            => _underlyingProperty.GetOptionalCustomModifiers();
+
+        public override Type[] GetRequiredCustomModifiers()
+            => _underlyingProperty.GetRequiredCustomModifiers();
+
+        public override bool IsDefined(Type attributeType, bool inherit)
+            => _underlyingProperty.IsDefined(attributeType, inherit);
+
+        public new bool IsOptional => _nullabilityInfo.ReadState != NullabilityState.NotNull;
     }
 
     private static partial class Log