Don't assume default value for optional value type argument without default value

src/HotChocolate/Core/src/Types/Types/InputParser.cs

@@ -614,14 +614,6 @@ private object DeserializeObject(object resultValue, InputObjectType type, Path
             }
 
             object? value = null;
-
-            // if the type is nullable but the runtime type is a non-nullable value
-            // we will create a default instance and assign that instead.
-            if (field.RuntimeType.IsValueType)
-            {
-                value = Activator.CreateInstance(field.RuntimeType);
-            }
-
             return field.IsOptional
                 ? new Optional(value, false)
                 : value;

src/HotChocolate/Core/src/Types/Utilities/Serialization/InputObjectCompiler.cs

@@ -243,6 +243,11 @@ private static void CompileSetProperties<T>(
             {
                 value = CreateOptional(value, field.RuntimeType);
             }
+            else if (field.Property.PropertyType.IsValueType
+                && System.Nullable.GetUnderlyingType(field.Property.PropertyType) == null)
+            {
+                value = Expression.Coalesce(value, Expression.Default(field.Property.PropertyType));
+            }
 
             value = Expression.Convert(value, field.Property.PropertyType);
             Expression setPropertyValue = Expression.Call(instance, setter, value);

src/HotChocolate/Core/test/Types.Tests/Types/InputParserTests.cs

@@ -493,6 +493,55 @@ public void Force_NonNull_Struct_To_Be_Optional()
         Assert.IsType<Test4Input>(runtimeValue).MatchSnapshot();
     }
 
+    [Fact]
+    public async Task Integration_CodeFirst_InputObjectNoDefaultValue_NoRuntimeTypeDefaultValueIsInitialized()
+    {
+        // arrange
+        var resolverArgumentsAccessor = new ResolverArgumentsAccessor();
+        var executor = await new ServiceCollection()
+            .AddSingleton(resolverArgumentsAccessor)
+            .AddGraphQL()
+            .AddQueryType(x => x.Field("foo")
+                                .Argument("args", a => a.Type<NonNullType<MyInputType>>())
+                                .Type<StringType>()
+                                .ResolveWith<ResolverArgumentsAccessor>(r => r.ResolveWith(default!)))
+            .BuildRequestExecutorAsync();
+
+        // act
+        var query =
+            OperationRequest.FromSourceText(
+                """
+                {
+                    a: foo(args: { string: "allSet" int: 1 bool: true })
+                    b: foo(args: { string: "noneSet" })
+                    c: foo(args: { string: "intExplicitlyNull" int: null })
+                    d: foo(args: { string: "boolExplicitlyNull" bool: null })
+                    e: foo(args: { string: "intSetBoolNull" int: 1 bool: null })
+                    f: foo(args: { string: "boolSetIntNull" int: null bool: true })
+                }
+                """);
+        await executor.ExecuteAsync(query, CancellationToken.None);
+
+        // assert
+        resolverArgumentsAccessor.Arguments.MatchSnapshot();
+    }
+
+    private class ResolverArgumentsAccessor
+    {
+        private readonly object _lock = new();
+        internal SortedDictionary<string, IDictionary<string, object?>?> Arguments { get; } = new();
+
+        internal string? ResolveWith(IDictionary<string, object?> args)
+        {
+            lock (_lock)
+            {
+                Arguments[args["string"]!.ToString()!] = args;
+            }
+
+            return "OK";
+        }
+    }
+
     public class TestInput
     {
         public string? Field1 { get; set; }
@@ -564,4 +613,15 @@ public class Test4Input
 
         public int Field2 { get; set; }
     }
+
+    public class MyInputType : InputObjectType
+    {
+        protected override void Configure(IInputObjectTypeDescriptor descriptor)
+        {
+            descriptor.Name("MyInput");
+            descriptor.Field("string").Type<StringType>();
+            descriptor.Field("int").Type<IntType>();
+            descriptor.Field("bool").Type<BooleanType>();
+        }
+    }
 }

src/HotChocolate/Core/test/Types.Tests/Types/__snapshots__/InputParserTests.Integration_CodeFirst_InputObjectNoDefaultValue_NoRuntimeTypeDefaultValueIsInitialized.snap

@@ -0,0 +1,32 @@
+{
+  "allSet": {
+    "string": "allSet",
+    "int": 1,
+    "bool": true
+  },
+  "boolExplicitlyNull": {
+    "string": "boolExplicitlyNull",
+    "int": null,
+    "bool": null
+  },
+  "boolSetIntNull": {
+    "string": "boolSetIntNull",
+    "int": null,
+    "bool": true
+  },
+  "intExplicitlyNull": {
+    "string": "intExplicitlyNull",
+    "int": null,
+    "bool": null
+  },
+  "intSetBoolNull": {
+    "string": "intSetBoolNull",
+    "int": 1,
+    "bool": null
+  },
+  "noneSet": {
+    "string": "noneSet",
+    "int": null,
+    "bool": null
+  }
+}