Support constructors with byref parameters (in/ref/out) in System.Text.Json

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectConverterFactory.cs

@@ -62,7 +62,14 @@ public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializer
                 foreach (ParameterInfo parameter in parameters)
                 {
                     // Every argument must be of supported type.
-                    JsonTypeInfo.ValidateType(parameter.ParameterType);
+                    // For byref parameters (in/ref/out), validate the underlying element type.
+                    Type parameterType = parameter.ParameterType;
+                    if (parameterType.IsByRef)
+                    {
+                        parameterType = parameterType.GetElementType()!;
+                    }
+
+                    JsonTypeInfo.ValidateType(parameterType);
                 }
 
                 if (parameterCount <= JsonConstants.UnboxedParameterCountThreshold)
@@ -75,7 +82,15 @@ public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializer
                     {
                         if (i < parameterCount)
                         {
-                            typeArguments[i + 1] = parameters[i].ParameterType;
+                            // For byref parameters (in/ref/out), use the underlying element type
+                            // since byref types cannot be used as generic type arguments.
+                            Type parameterType = parameters[i].ParameterType;
+                            if (parameterType.IsByRef)
+                            {
+                                parameterType = parameterType.GetElementType()!;
+                            }
+
+                            typeArguments[i + 1] = parameterType;
                         }
                         else
                         {

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/DefaultJsonTypeInfoResolver.Helpers.cs

@@ -301,10 +301,17 @@ private static void PopulateParameterInfoValues(JsonTypeInfo typeInfo, Nullabili
                     ThrowHelper.ThrowNotSupportedException_ConstructorContainsNullParameterNames(typeInfo.Converter.ConstructorInfo.DeclaringType);
                 }
 
+                // For byref parameters (in/ref/out), use the underlying element type.
+                Type parameterType = reflectionInfo.ParameterType;
+                if (parameterType.IsByRef)
+                {
+                    parameterType = parameterType.GetElementType()!;
+                }
+
                 JsonParameterInfoValues jsonInfo = new()
                 {
                     Name = reflectionInfo.Name,
-                    ParameterType = reflectionInfo.ParameterType,
+                    ParameterType = parameterType,
                     Position = reflectionInfo.Position,
                     HasDefaultValue = reflectionInfo.HasDefaultValue,
                     DefaultValue = reflectionInfo.GetDefaultValue(),

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/ReflectionEmitMemberAccessor.cs

@@ -91,14 +91,44 @@ private static DynamicMethod CreateParameterizedConstructor(ConstructorInfo cons
 
             ILGenerator generator = dynamicMethod.GetILGenerator();
 
+            // For byref parameters, we need to store values in local variables and pass addresses.
+            LocalBuilder?[] locals = new LocalBuilder?[parameterCount];
+            for (int i = 0; i < parameterCount; i++)
+            {
+                Type paramType = parameters[i].ParameterType;
+                if (paramType.IsByRef)
+                {
+                    // Declare a local for the underlying type.
+                    Type elementType = paramType.GetElementType()!;
+                    locals[i] = generator.DeclareLocal(elementType);
+
+                    // Load value from object array, unbox it, and store in the local.
+                    generator.Emit(OpCodes.Ldarg_0);
+                    generator.Emit(OpCodes.Ldc_I4, i);
+                    generator.Emit(OpCodes.Ldelem_Ref);
+                    generator.Emit(OpCodes.Unbox_Any, elementType);
+                    generator.Emit(OpCodes.Stloc, locals[i]!);
+                }
+            }
+
+            // Now push all arguments onto the stack.
             for (int i = 0; i < parameterCount; i++)
             {
                 Type paramType = parameters[i].ParameterType;
 
-                generator.Emit(OpCodes.Ldarg_0);
-                generator.Emit(OpCodes.Ldc_I4, i);
-                generator.Emit(OpCodes.Ldelem_Ref);
-                generator.Emit(OpCodes.Unbox_Any, paramType);
+                if (paramType.IsByRef)
+                {
+                    // Load address of the local variable.
+                    generator.Emit(OpCodes.Ldloca, locals[i]!);
+                }
+                else
+                {
+                    // Load value from object array and unbox.
+                    generator.Emit(OpCodes.Ldarg_0);
+                    generator.Emit(OpCodes.Ldc_I4, i);
+                    generator.Emit(OpCodes.Ldelem_Ref);
+                    generator.Emit(OpCodes.Unbox_Any, paramType);
+                }
             }
 
             generator.Emit(OpCodes.Newobj, constructor);
@@ -136,15 +166,25 @@ public override JsonTypeInfo.ParameterizedConstructorDelegate<T, TArg0, TArg1, T
             {
                 Debug.Assert(index <= JsonConstants.UnboxedParameterCountThreshold);
 
-                generator.Emit(
-                    index switch
-                    {
-                        0 => OpCodes.Ldarg_0,
-                        1 => OpCodes.Ldarg_1,
-                        2 => OpCodes.Ldarg_2,
-                        3 => OpCodes.Ldarg_3,
-                        _ => throw new InvalidOperationException()
-                    });
+                // For byref parameters (in/ref/out), load the address of the argument instead of the value.
+                bool isByRef = parameters[index].ParameterType.IsByRef;
+
+                if (isByRef)
+                {
+                    generator.Emit(OpCodes.Ldarga_S, index);
+                }
+                else
+                {
+                    generator.Emit(
+                        index switch
+                        {
+                            0 => OpCodes.Ldarg_0,
+                            1 => OpCodes.Ldarg_1,
+                            2 => OpCodes.Ldarg_2,
+                            3 => OpCodes.Ldarg_3,
+                            _ => throw new InvalidOperationException()
+                        });
+                }
             }
 
             generator.Emit(OpCodes.Newobj, constructor);

src/libraries/System.Text.Json/tests/Common/ConstructorTests/ConstructorTests.ParameterMatching.cs

@@ -1841,5 +1841,83 @@ public class ClassWithRequiredProperty
         {
             public required string? Bar { get; set; }
         }
+
+        [Fact]
+        public async Task DeserializeType_WithInParameters()
+        {
+            string json = @"{""DateTime"":""2020-12-15T00:00:00"",""TimeSpan"":""01:02:03""}";
+            TypeWith_InParameters result = await Serializer.DeserializeWrapper<TypeWith_InParameters>(json);
+            Assert.Equal(new DateTime(2020, 12, 15), result.DateTime);
+            Assert.Equal(new TimeSpan(1, 2, 3), result.TimeSpan);
+        }
+
+        public class TypeWith_InParameters
+        {
+            public TypeWith_InParameters(in DateTime dateTime, in TimeSpan timeSpan)
+            {
+                DateTime = dateTime;
+                TimeSpan = timeSpan;
+            }
+
+            public DateTime DateTime { get; set; }
+            public TimeSpan TimeSpan { get; set; }
+        }
+
+        [Fact]
+        public async Task DeserializeType_WithMixedByRefParameters()
+        {
+            string json = @"{""Value1"":42,""Value2"":""hello"",""Value3"":3.14,""Value4"":true}";
+            TypeWith_MixedByRefParameters result = await Serializer.DeserializeWrapper<TypeWith_MixedByRefParameters>(json);
+            Assert.Equal(42, result.Value1);
+            Assert.Equal("hello", result.Value2);
+            Assert.Equal(3.14, result.Value3);
+            Assert.True(result.Value4);
+        }
+
+        public class TypeWith_MixedByRefParameters
+        {
+            public TypeWith_MixedByRefParameters(in int value1, string value2, in double value3, bool value4)
+            {
+                Value1 = value1;
+                Value2 = value2;
+                Value3 = value3;
+                Value4 = value4;
+            }
+
+            public int Value1 { get; set; }
+            public string Value2 { get; set; }
+            public double Value3 { get; set; }
+            public bool Value4 { get; set; }
+        }
+
+        [Fact]
+        public async Task DeserializeType_WithLargeInParameters()
+        {
+            string json = @"{""A"":1,""B"":2,""C"":3,""D"":4,""E"":5}";
+            TypeWith_LargeInParameters result = await Serializer.DeserializeWrapper<TypeWith_LargeInParameters>(json);
+            Assert.Equal(1, result.A);
+            Assert.Equal(2, result.B);
+            Assert.Equal(3, result.C);
+            Assert.Equal(4, result.D);
+            Assert.Equal(5, result.E);
+        }
+
+        public class TypeWith_LargeInParameters
+        {
+            public TypeWith_LargeInParameters(in int a, in int b, in int c, in int d, in int e)
+            {
+                A = a;
+                B = b;
+                C = c;
+                D = d;
+                E = e;
+            }
+
+            public int A { get; set; }
+            public int B { get; set; }
+            public int C { get; set; }
+            public int D { get; set; }
+            public int E { get; set; }
+        }
     }
 }

src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/ConstructorTests.cs

@@ -159,6 +159,9 @@ protected ConstructorTests_Metadata(JsonSerializerWrapper stringWrapper)
         [JsonSerializable(typeof(Class_ExtraProperty_JsonElementDictionaryExtData))]
         [JsonSerializable(typeof(Class_ManyParameters_ExtraProperty_ExtData))]
         [JsonSerializable(typeof(ClassWithRequiredProperty))]
+        [JsonSerializable(typeof(TypeWith_InParameters))]
+        [JsonSerializable(typeof(TypeWith_MixedByRefParameters))]
+        [JsonSerializable(typeof(TypeWith_LargeInParameters))]
         internal sealed partial class ConstructorTestsContext_Metadata : JsonSerializerContext
         {
         }
@@ -313,6 +316,9 @@ public ConstructorTests_Default(JsonSerializerWrapper jsonSerializer) : base(jso
         [JsonSerializable(typeof(Class_ExtraProperty_JsonElementDictionaryExtData))]
         [JsonSerializable(typeof(Class_ManyParameters_ExtraProperty_ExtData))]
         [JsonSerializable(typeof(ClassWithRequiredProperty))]
+        [JsonSerializable(typeof(TypeWith_InParameters))]
+        [JsonSerializable(typeof(TypeWith_MixedByRefParameters))]
+        [JsonSerializable(typeof(TypeWith_LargeInParameters))]
         internal sealed partial class ConstructorTestsContext_Default : JsonSerializerContext
         {
         }