Fixed argument naming conventions for mutation conventions.

src/HotChocolate/Core/src/Types.Mutations/Errors/ErrorMiddleware.cs

@@ -1,17 +1,11 @@
 namespace HotChocolate.Types;
 
-internal sealed class ErrorMiddleware
+internal sealed class ErrorMiddleware(FieldDelegate next, IReadOnlyList<CreateError> errorHandlers)
 {
-    private readonly FieldDelegate _next;
-    private readonly IReadOnlyList<CreateError> _errorHandlers;
-
-    public ErrorMiddleware(FieldDelegate next, IReadOnlyList<CreateError> errorHandlers)
-    {
-        _next = next ??
-            throw new ArgumentNullException(nameof(next));
-        _errorHandlers = errorHandlers ??
-            throw new ArgumentNullException(nameof(errorHandlers));
-    }
+    private readonly FieldDelegate _next = next ??
+        throw new ArgumentNullException(nameof(next));
+    private readonly IReadOnlyList<CreateError> _errorHandlers = errorHandlers ??
+        throw new ArgumentNullException(nameof(errorHandlers));
 
     public async ValueTask InvokeAsync(IMiddlewareContext context)
     {

src/HotChocolate/Core/src/Types.Mutations/Errors/ErrorNullMiddleware.cs

@@ -2,7 +2,8 @@ namespace HotChocolate.Types;
 
 internal sealed class ErrorNullMiddleware(FieldDelegate next)
 {
-    private readonly FieldDelegate _next = next ?? throw new ArgumentNullException(nameof(next));
+    private readonly FieldDelegate _next = next ?? 
+        throw new ArgumentNullException(nameof(next));
 
     public async ValueTask InvokeAsync(IMiddlewareContext context)
     {

src/HotChocolate/Core/src/Types.Mutations/Errors/ErrorObjectType.cs

@@ -1,7 +1,5 @@
 using System.Linq;
 
-#nullable enable
-
 namespace HotChocolate.Types;
 
 internal sealed class ErrorObjectType<T> : ObjectType<T>

src/HotChocolate/Core/src/Types.Mutations/Extensions/MutationObjectFieldDescriptorExtensions.cs

@@ -1,5 +1,3 @@
-#nullable enable
-
 namespace HotChocolate.Types;
 
 /// <summary>

src/HotChocolate/Core/src/Types.Mutations/Extensions/ObjectFieldDefinitionExtensions.cs

@@ -1,8 +1,6 @@
 using static HotChocolate.Properties.TypeResources;
 using static HotChocolate.Types.ErrorContextDataKeys;
 
-#nullable enable
-
 namespace HotChocolate.Types;
 
 /// <summary>

src/HotChocolate/Core/src/Types.Mutations/MutationContextData.cs

@@ -4,43 +4,31 @@ namespace HotChocolate.Types;
 /// This internal data structure is used to store the effective mutation options of a field
 /// on the context so that the type interceptor can access them.
 /// </summary>
-internal sealed class MutationContextData
+internal sealed class MutationContextData(
+    ObjectFieldDefinition definition,
+    string? inputTypeName,
+    string? inputArgumentName,
+    string? payloadTypeName,
+    string? payloadFieldName,
+    string? payloadErrorTypeName,
+    string? payloadErrorsFieldName,
+    bool enabled)
 {
-    public MutationContextData(
-        ObjectFieldDefinition definition,
-        string? inputTypeName,
-        string? inputArgumentName,
-        string? payloadTypeName,
-        string? payloadFieldName,
-        string? payloadErrorTypeName,
-        string? payloadErrorsFieldName,
-        bool enabled)
-    {
-        Definition = definition;
-        InputTypeName = inputTypeName;
-        InputArgumentName = inputArgumentName;
-        PayloadTypeName = payloadTypeName;
-        PayloadFieldName = payloadFieldName;
-        PayloadPayloadErrorTypeName = payloadErrorTypeName;
-        PayloadErrorsFieldName = payloadErrorsFieldName;
-        Enabled = enabled;
-    }
-
     public string Name => Definition.Name;
 
-    public ObjectFieldDefinition Definition { get; }
+    public ObjectFieldDefinition Definition { get; } = definition;
 
-    public string? InputTypeName { get; }
+    public string? InputTypeName { get; } = inputTypeName;
 
-    public string? InputArgumentName { get; }
+    public string? InputArgumentName { get; } = inputArgumentName;
 
-    public string? PayloadFieldName { get; }
+    public string? PayloadFieldName { get; } = payloadFieldName;
 
-    public string? PayloadTypeName { get; }
+    public string? PayloadTypeName { get; } = payloadTypeName;
 
-    public string? PayloadPayloadErrorTypeName { get; }
+    public string? PayloadPayloadErrorTypeName { get; } = payloadErrorTypeName;
 
-    public string? PayloadErrorsFieldName { get; }
+    public string? PayloadErrorsFieldName { get; } = payloadErrorsFieldName;
 
-    public bool Enabled { get; }
+    public bool Enabled { get; } = enabled;
 }

src/HotChocolate/Core/src/Types.Mutations/MutationContextDataKeys.cs

@@ -1,5 +1,3 @@
-#nullable enable
-
 namespace HotChocolate.Types;
 
 internal static class MutationContextDataKeys

src/HotChocolate/Core/src/Types.Mutations/MutationConventionMiddleware.cs

@@ -8,24 +8,17 @@ namespace HotChocolate.Types;
 /// This middleware ensures that the rewritten argument structure is remapped so that the
 /// resolver can request the arguments in the original structure.
 /// </summary>
-internal sealed class MutationConventionMiddleware
+internal sealed class MutationConventionMiddleware(
+    FieldDelegate next,
+    string inputArgumentName,
+    IReadOnlyList<ResolverArgument> resolverArguments)
 {
-    private readonly FieldDelegate _next;
-    private readonly string _inputArgumentName;
-    private readonly IReadOnlyList<ResolverArgument> _resolverArguments;
-
-    public MutationConventionMiddleware(
-        FieldDelegate next,
-        string inputArgumentName,
-        IReadOnlyList<ResolverArgument> resolverArguments)
-    {
-        _next = next ??
-            throw new ArgumentNullException(nameof(next));
-        _inputArgumentName = inputArgumentName ??
-            throw new ArgumentNullException(nameof(inputArgumentName));
-        _resolverArguments = resolverArguments ??
-            throw new ArgumentNullException(nameof(resolverArguments));
-    }
+    private readonly FieldDelegate _next = next ??
+        throw new ArgumentNullException(nameof(next));
+    private readonly string _inputArgumentName = inputArgumentName ??
+        throw new ArgumentNullException(nameof(inputArgumentName));
+    private readonly IReadOnlyList<ResolverArgument> _resolverArguments = resolverArguments ??
+        throw new ArgumentNullException(nameof(resolverArguments));
 
     public async ValueTask InvokeAsync(IMiddlewareContext context)
     {

src/HotChocolate/Core/src/Types.Mutations/MutationConventionTypeInterceptor.cs

@@ -1,4 +1,5 @@
 using System.Linq;
+using HotChocolate.Types.Helpers;
 using static HotChocolate.WellKnownMiddleware;
 using static HotChocolate.Types.Descriptors.TypeReference;
 using static HotChocolate.Resolvers.FieldClassMiddlewareFactory;
@@ -8,8 +9,6 @@
 using static HotChocolate.Utilities.ThrowHelper;
 using static HotChocolate.WellKnownContextData;
 
-#nullable enable
-
 namespace HotChocolate.Types;
 
 internal sealed class MutationConventionTypeInterceptor : TypeInterceptor
@@ -99,7 +98,7 @@ internal override void OnBeforeCompleteMutation(
         // on the mutations.
         if (_mutationTypeDef is not null)
         {
-            HashSet<MutationContextData> unprocessed = new(_mutations);
+            HashSet<MutationContextData> unprocessed = [.._mutations];
             var defLookup = _mutations.ToDictionary(t => t.Definition);
             var nameLookup = _mutations.ToDictionary(t => t.Name);
             var rootOptions = CreateOptions(_context.ContextData);
@@ -137,7 +136,7 @@ internal override void OnBeforeCompleteMutation(
                     // if the mutation options indicate that we shall apply the mutation
                     // conventions we will start rewriting the field.
                     ApplyResultMiddleware(mutationField);
-                    TryApplyInputConvention(mutationField, mutationOptions);
+                    TryApplyInputConvention(_context.ResolverCompiler, mutationField, mutationOptions);
                     TryApplyPayloadConvention(mutationField, cd?.PayloadFieldName, mutationOptions);
                 }
             }
@@ -181,13 +180,38 @@ private static void ApplyResultMiddleware(ObjectFieldDefinition mutation)
         mutation.MiddlewareDefinitions.Insert(0, middlewareDef);
     }
 
-    private void TryApplyInputConvention(ObjectFieldDefinition mutation, Options options)
+    private void TryApplyInputConvention(
+        IResolverCompiler resolverCompiler,
+        ObjectFieldDefinition mutation, 
+        Options options)
     {
         if (mutation.Arguments.Count is 0)
         {
             return;
         }
 
+        if (mutation.Member is not null)
+        {
+            var argumentNameMap = TypeMemHelper.RentArgumentNameMap();
+
+            foreach (var arg in mutation.Arguments)
+            {
+                if (arg.Parameter is not null)
+                {
+                    argumentNameMap.Add(arg.Parameter, arg.Name);
+                }
+            }
+
+            mutation.Resolvers =
+                resolverCompiler.CompileResolve(
+                    mutation.Member,
+                    mutation.SourceType,
+                    mutation.ResolverType,
+                    argumentNameMap);
+
+            TypeMemHelper.Return(argumentNameMap);
+        }
+
         var inputTypeName = options.FormatInputTypeName(mutation.Name);
 
         if (_typeRegistry.NameRefs.ContainsKey(inputTypeName))

src/HotChocolate/Core/src/Types.Mutations/MutationResultTypeDiscoveryHandler.cs

@@ -2,14 +2,10 @@
 
 namespace HotChocolate.Types;
 
-internal sealed class MutationResultTypeDiscoveryHandler : TypeDiscoveryHandler
+internal sealed class MutationResultTypeDiscoveryHandler(ITypeInspector typeInspector) : TypeDiscoveryHandler
 {
-    private readonly ITypeInspector _typeInspector;
-
-    public MutationResultTypeDiscoveryHandler(ITypeInspector typeInspector)
-    {
-        _typeInspector = typeInspector ?? throw new ArgumentNullException(nameof(typeInspector));
-    }
+    private readonly ITypeInspector _typeInspector = typeInspector ?? 
+        throw new ArgumentNullException(nameof(typeInspector));
 
     public override bool TryInferType(
         TypeReference typeReference,

src/HotChocolate/Core/src/Types.Mutations/ResolverArgument.cs

@@ -1,35 +1,24 @@
-#nullable enable
-
 namespace HotChocolate.Types;
 
-internal sealed class ResolverArgument : IInputFieldInfo
+internal sealed class ResolverArgument(
+    string name,
+    FieldCoordinate coordinate,
+    IInputType type,
+    Type runtimeType,
+    IValueNode? defaultValue,
+    IInputValueFormatter? formatter)
+    : IInputFieldInfo
 {
-    public ResolverArgument(
-        string name,
-        FieldCoordinate coordinate,
-        IInputType type,
-        Type runtimeType,
-        IValueNode? defaultValue,
-        IInputValueFormatter? formatter)
-    {
-        Name = name;
-        Coordinate = coordinate;
-        RuntimeType = runtimeType;
-        Type = type;
-        DefaultValue = defaultValue;
-        Formatter = formatter;
-    }
-
-    public string Name { get; }
+    public string Name { get; } = name;
 
-    public FieldCoordinate Coordinate { get; }
+    public FieldCoordinate Coordinate { get; } = coordinate;
 
-    public IInputType Type { get; }
+    public IInputType Type { get; } = type;
 
-    public Type RuntimeType { get; }
+    public Type RuntimeType { get; } = runtimeType;
 
-    public IValueNode? DefaultValue { get; }
+    public IValueNode? DefaultValue { get; } = defaultValue;
 
-    public IInputValueFormatter? Formatter { get; }
+    public IInputValueFormatter? Formatter { get; } = formatter;
 }
 

src/HotChocolate/Core/src/Types.Mutations/UseMutationConventionAttribute.cs

@@ -1,5 +1,3 @@
-using System.Linq;
-
 namespace HotChocolate.Types;
 
 /// <summary>