Reworked / harmonized error handling and propagation for custom TypeConverter-errors

src/HotChocolate/Core/src/Execution.Abstractions/ErrorBuilder.cs

@@ -85,6 +85,38 @@ public ErrorBuilder AddLocation(Location location)
         return this;
     }
 
+    /// <summary>
+    /// Adds a GraphQL operation document location to the error, if the error does not already have a location.
+    /// </summary>
+    /// <param name="location">The location of the error.</param>
+    /// <returns>The error builder.</returns>
+    public ErrorBuilder TryAddLocation(Location location)
+    {
+        if (_locations == null || _locations.Count == 0)
+        {
+            _locations ??= [];
+            _locations.Add(location);
+        }
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds a GraphQL operation document location to the error.
+    /// </summary>
+    /// <param name="location">The location of the error.</param>
+    /// <returns>The error builder.</returns>
+    public ErrorBuilder TryAddLocation(Language.Location? location)
+    {
+        if (location != null && (_locations == null || _locations.Count == 0))
+        {
+            _locations ??= [];
+            _locations.Add(new Location(location.Line, location.Column));
+        }
+
+        return this;
+    }
+
     /// <summary>
     /// Clears the locations of the error.
     /// </summary>

src/HotChocolate/Core/src/Execution.Abstractions/ErrorBuilderExtensions.cs

@@ -12,15 +12,30 @@ public static class ErrorBuilderExtensions
     /// Sets the field coordinate of the error.
     /// </summary>
     /// <param name="builder">The error builder.</param>
-    /// <param name="fieldCoordinate">The field coordinate.</param>
+    /// <param name="coordinate">The field coordinate.</param>
     /// <returns>The error builder.</returns>
-    public static ErrorBuilder SetFieldCoordinate(
+    public static ErrorBuilder SetCoordinate(
         this ErrorBuilder builder,
-        SchemaCoordinate fieldCoordinate)
+        SchemaCoordinate coordinate)
     {
         ArgumentNullException.ThrowIfNull(builder);
 
-        return builder.SetExtension(nameof(fieldCoordinate), fieldCoordinate.ToString());
+        return builder.SetExtension(nameof(coordinate), coordinate.ToString());
+    }
+
+    /// <summary>
+    /// Sets the input path of the error.
+    /// </summary>
+    /// <param name="builder">The error builder.</param>
+    /// <param name="inputPath">The input path.</param>
+    /// <returns>The error builder.</returns>
+    public static ErrorBuilder SetInputPath(
+        this ErrorBuilder builder,
+        Path inputPath)
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+
+        return builder.SetExtension(nameof(inputPath), inputPath);
     }
 
     /// <summary>
@@ -58,6 +73,23 @@ public static ErrorBuilder AddLocation(this ErrorBuilder builder, ISyntaxNode no
         return builder;
     }
 
+    /// <summary>
+    /// Adds a location to the error if the error does not already have a location.
+    /// </summary>
+    /// <param name="builder">The error builder.</param>
+    /// <param name="node">The syntax node.</param>
+    /// <returns>The error builder.</returns>
+    public static ErrorBuilder TryAddLocation(this ErrorBuilder builder, ISyntaxNode? node)
+    {
+        if (node?.Location is null)
+        {
+            return builder;
+        }
+
+        builder.TryAddLocation(new Location(node.Location.Line, node.Location.Column));
+        return builder;
+    }
+
     /// <summary>
     /// Adds multiple locations to the error.
     /// </summary>

src/HotChocolate/Core/src/Execution/ErrorHelper.cs

@@ -10,36 +10,23 @@ internal static class ErrorHelper
 {
     public static IError ArgumentNonNullError(
         ArgumentNode argument,
-        string responseName,
         ArgumentNonNullValidator.ValidationResult validationResult)
     {
         return ErrorBuilder.New()
             .SetMessage(
                 ErrorHelper_ArgumentNonNullError_Message,
                 argument.Name.Value)
             .AddLocation(argument)
-            .SetExtension("responseName", responseName)
             .SetExtension("errorPath", validationResult.Path)
             .Build();
     }
 
     public static IError ArgumentValueIsInvalid(
-        ArgumentNode argument,
-        string responseName,
+        ArgumentNode? argument,
         GraphQLException exception)
     {
         return ErrorBuilder.FromError(exception.Errors[0])
-            .AddLocation(argument)
-            .SetExtension("responseName", responseName)
-            .Build();
-    }
-
-    public static IError ArgumentDefaultValueIsInvalid(
-        string responseName,
-        GraphQLException exception)
-    {
-        return ErrorBuilder.FromError(exception.Errors[0])
-            .SetExtension("responseName", responseName)
+            .TryAddLocation(argument)
             .Build();
     }
 
@@ -49,7 +36,7 @@ public static IError InvalidLeafValue(
         Path path)
     {
         return ErrorBuilder.FromError(exception.Errors[0])
-            .AddLocation(field)
+            .TryAddLocation(field)
             .SetPath(path)
             .SetCode(ErrorCodes.Execution.CannotSerializeLeafValue)
             .Build();

src/HotChocolate/Core/src/Execution/Processing/MiddlewareContext.Arguments.cs

@@ -20,7 +20,18 @@ public T ArgumentValue<T>(string name)
             throw ResolverContext_ArgumentDoesNotExist(_selection.SyntaxNode, Path, name);
         }
 
-        return CoerceArgumentValue<T>(argument);
+        try
+        {
+            return CoerceArgumentValue<T>(argument);
+        }
+        catch (SerializationException ex)
+        {
+            var syntaxNode = Selection.Arguments[argument.Name].ValueLiteral;
+            throw new SerializationException(
+                ErrorBuilder.FromError(ex.Errors[0]).SetPath(Path).TryAddLocation(syntaxNode).Build(),
+                ex.Type,
+                Path);
+        }
     }
 
     public Optional<T> ArgumentOptional<T>(string name)
@@ -94,7 +105,7 @@ private T CoerceArgumentValue<T>(ArgumentValue argument)
         }
 
         if (value is T castedValue
-            || _operationContext.Converter.TryConvert(value, out castedValue))
+            || _operationContext.Converter.TryConvert(value, out castedValue, out var conversionException))
         {
             return castedValue;
         }
@@ -114,7 +125,8 @@ private T CoerceArgumentValue<T>(ArgumentValue argument)
             _selection.SyntaxNode,
             Path,
             argument.Name,
-            typeof(T));
+            typeof(T),
+            conversionException);
     }
 
     public IReadOnlyDictionary<string, ArgumentValue> ReplaceArguments(

src/HotChocolate/Core/src/Execution/Processing/MiddlewareContext.Pure.cs

@@ -234,7 +234,7 @@ private T CoerceArgumentValue<T>(ArgumentValue argument)
                 DefaultTypeConverter.Default;
 
             if (value is T castedValue
-                || _typeConverter.TryConvert(value, out castedValue))
+                || _typeConverter.TryConvert(value, out castedValue, out var conversionException))
             {
                 return castedValue;
             }
@@ -270,7 +270,11 @@ private T CoerceArgumentValue<T>(ArgumentValue argument)
 
             // we are unable to convert the argument to the request type.
             throw ResolverContext_CannotConvertArgument(
-                _selection.SyntaxNode, Path, argument.Name, typeof(T));
+                _selection.SyntaxNode,
+                Path,
+                argument.Name,
+                typeof(T),
+                conversionException);
         }
     }
 }

src/HotChocolate/Core/src/Execution/Processing/OperationCompiler.ArgumentValues.cs

@@ -1,3 +1,4 @@
+using System.Diagnostics;
 using HotChocolate.Language;
 using HotChocolate.Resolvers;
 using HotChocolate.Types;
@@ -9,8 +10,7 @@ public sealed partial class OperationCompiler
 {
     private ArgumentMap? CoerceArgumentValues(
         ObjectField field,
-        FieldNode selection,
-        string responseName)
+        FieldNode selection)
     {
         if (field.Arguments.Count == 0)
         {
@@ -26,13 +26,7 @@ public sealed partial class OperationCompiler
                 argumentValue.Name.Value,
                 out var argument))
             {
-                arguments[argument.Name] =
-                    CreateArgumentValue(
-                        responseName,
-                        argument,
-                        argumentValue,
-                        argumentValue.Value,
-                        false);
+                arguments[argument.Name] = CreateArgumentValue(argument, argumentValue, argumentValue.Value, false);
             }
         }
 
@@ -41,21 +35,15 @@ public sealed partial class OperationCompiler
             var argument = field.Arguments[i];
             if (!arguments.ContainsKey(argument.Name))
             {
-                arguments[argument.Name] =
-                    CreateArgumentValue(
-                        responseName,
-                        argument,
-                        null,
-                        argument.DefaultValue ?? NullValueNode.Default,
-                        true);
+                var value = argument.DefaultValue ?? NullValueNode.Default;
+                arguments[argument.Name] = CreateArgumentValue(argument, null, value, true);
             }
         }
 
         return new ArgumentMap(arguments);
     }
 
     private ArgumentValue CreateArgumentValue(
-        string responseName,
         Argument argument,
         ArgumentNode? argumentValue,
         IValueNode value,
@@ -73,7 +61,6 @@ private ArgumentValue CreateArgumentValue(
                 argument,
                 ErrorHelper.ArgumentNonNullError(
                     argumentValue,
-                    responseName,
                     validationResult));
         }
 
@@ -91,16 +78,9 @@ private ArgumentValue CreateArgumentValue(
             }
             catch (SerializationException ex)
             {
-                if (argumentValue is not null)
-                {
-                    return new ArgumentValue(
-                        argument,
-                        ErrorHelper.ArgumentValueIsInvalid(argumentValue, responseName, ex));
-                }
-
                 return new ArgumentValue(
                     argument,
-                    ErrorHelper.ArgumentDefaultValueIsInvalid(responseName, ex));
+                    ErrorHelper.ArgumentValueIsInvalid(argumentValue, ex));
             }
         }
 
@@ -140,6 +120,7 @@ internal static FieldDelegate CreateFieldPipeline(
         Schema schema,
         ObjectField field,
         FieldNode selection,
+        Path? path,
         HashSet<string> processed,
         List<FieldMiddleware> pipelineComponents)
     {
@@ -152,7 +133,7 @@ internal static FieldDelegate CreateFieldPipeline(
 
         // if we have selection directives we will inspect them and try to build a
         // pipeline from them if they have middleware components.
-        BuildDirectivePipeline(schema, selection, processed, pipelineComponents);
+        BuildDirectivePipeline(schema, selection, path, processed, pipelineComponents);
 
         // if we found middleware components on the selection directives we will build a new
         // pipeline.
@@ -200,6 +181,7 @@ internal static FieldDelegate CreateFieldPipeline(
     private static void BuildDirectivePipeline(
         Schema schema,
         FieldNode selection,
+        Path? path,
         HashSet<string> processed,
         List<FieldMiddleware> pipelineComponents)
     {
@@ -210,10 +192,23 @@ private static void BuildDirectivePipeline(
                 && directiveType.Middleware is not null
                 && (directiveType.IsRepeatable || processed.Add(directiveType.Name)))
             {
-                var directive = new Directive(
-                    directiveType,
-                    directiveNode,
-                    directiveType.Parse(directiveNode));
+                Debug.Assert(path != null, "path should not be null if a directive is present.");
+                Directive directive;
+                try
+                {
+                    directive = new Directive(
+                        directiveType,
+                        directiveNode,
+                        directiveType.Parse(directiveNode));
+                }
+                catch (SerializationException ex)
+                {
+                    throw new SerializationException(
+                        ErrorBuilder.FromError(ex.Errors[0]).SetPath(path).TryAddLocation(directiveNode).Build(),
+                        ex.Type,
+                        path);
+                }
+
                 var directiveMiddleware = directiveType.Middleware;
                 pipelineComponents.Add(next => directiveMiddleware(next, directive));
             }

src/HotChocolate/Core/src/Execution/Processing/OperationCompiler.cs

@@ -50,6 +50,7 @@ public OperationCompiler(InputParser parser)
                     schema,
                     field,
                     selection,
+                    null,
                     _directiveNames,
                     _pipelineComponents);
     }
@@ -221,18 +222,26 @@ private void CompleteResolvers(Schema schema)
     {
         ref var searchSpace = ref GetReference(AsSpan(_selections));
 
+        Path? path = null;
         for (var i = 0; i < _selections.Count; i++)
         {
             var selection = Unsafe.Add(ref searchSpace, i);
-
+            path = path?.Append(selection.ResponseName);
             if (selection.ResolverPipeline is null && selection.PureResolver is null)
             {
-                var field = Unsafe.As<ObjectField>(selection.Field);
+                var field = selection.Field;
                 var syntaxNode = selection.SyntaxNode;
+                if (syntaxNode.Directives.Count > 0 && path == null)
+                {
+                    // create the path only on demand
+                    path = PathHelper.CreatePathFromSelection(_selections, i + 1);
+                }
+
                 var resolver = CreateFieldPipeline(
                     schema,
                     field,
                     syntaxNode,
+                    path,
                     _directiveNames,
                     _pipelineComponents);
                 var pureResolver = TryCreatePureField(schema, field, syntaxNode);
@@ -446,7 +455,7 @@ selection.SelectionSet is not null
                                 selection.SelectionSet.Selections))
                         : selection,
                     responseName: responseName,
-                    arguments: CoerceArgumentValues(field, selection, responseName),
+                    arguments: CoerceArgumentValues(field, selection),
                     includeConditions: includeCondition == 0
                         ? null
                         : [includeCondition],