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

src/libraries/System.Text.Json/gen/JsonSourceGenerator.Emitter.cs

@@ -935,14 +935,38 @@ private static string GetParameterizedCtorInvocationFunc(TypeGenerationSpec type
 
                 const string ArgsVarName = "args";
 
-                StringBuilder sb = new($"static {ArgsVarName} => new {typeGenerationSpec.TypeRef.FullyQualifiedName}(");
+                // RefKind values from Microsoft.CodeAnalysis.RefKind:
+                // None = 0, Ref = 1, Out = 2, In = 3, RefReadOnlyParameter = 4
+                bool hasRefOrRefReadonlyParams = parameters.Any(p => p.RefKind == 1 || p.RefKind == 4); // Ref or RefReadOnlyParameter
+
+                StringBuilder sb;
+
+                if (hasRefOrRefReadonlyParams)
+                {
+                    // For ref/ref readonly parameters, we need a block lambda with temp variables
+                    sb = new($"static {ArgsVarName} => {{ ");
+
+                    // Declare temp variables for ref and ref readonly parameters
+                    foreach (ParameterGenerationSpec param in parameters)
+                    {
+                        if (param.RefKind == 1 || param.RefKind == 4) // Ref or RefReadOnlyParameter
+                        {
+                            sb.Append($"var __temp{param.ParameterIndex} = ({param.ParameterType.FullyQualifiedName}){ArgsVarName}[{param.ParameterIndex}]; ");
+                        }
+                    }
+
+                    sb.Append($"return new {typeGenerationSpec.TypeRef.FullyQualifiedName}(");
+                }
+                else
+                {
+                    sb = new($"static {ArgsVarName} => new {typeGenerationSpec.TypeRef.FullyQualifiedName}(");
+                }
 
                 if (parameters.Count > 0)
                 {
                     foreach (ParameterGenerationSpec param in parameters)
                     {
-                        int index = param.ParameterIndex;
-                        sb.Append($"{GetParamUnboxing(param.ParameterType, index)}, ");
+                        sb.Append($"{GetParamExpression(param)}, ");
                     }
 
                     sb.Length -= 2; // delete the last ", " token
@@ -955,17 +979,31 @@ private static string GetParameterizedCtorInvocationFunc(TypeGenerationSpec type
                     sb.Append("{ ");
                     foreach (PropertyInitializerGenerationSpec property in propertyInitializers)
                     {
-                        sb.Append($"{property.Name} = {GetParamUnboxing(property.ParameterType, property.ParameterIndex)}, ");
+                        sb.Append($"{property.Name} = ({property.ParameterType.FullyQualifiedName}){ArgsVarName}[{property.ParameterIndex}], ");
                     }
 
                     sb.Length -= 2; // delete the last ", " token
                     sb.Append(" }");
                 }
 
+                if (hasRefOrRefReadonlyParams)
+                {
+                    sb.Append("; }");
+                }
+
                 return sb.ToString();
 
-                static string GetParamUnboxing(TypeRef type, int index)
-                    => $"({type.FullyQualifiedName}){ArgsVarName}[{index}]";
+                static string GetParamExpression(ParameterGenerationSpec param)
+                {
+                    // RefKind values: None = 0, Ref = 1, Out = 2, In = 3, RefReadOnlyParameter = 4
+                    return param.RefKind switch
+                    {
+                        1 => $"ref __temp{param.ParameterIndex}", // Ref
+                        2 => $"out var __discard{param.ParameterIndex}", // Out - use discard pattern
+                        4 => $"in __temp{param.ParameterIndex}", // RefReadOnlyParameter - use in keyword with temp
+                        _ => $"({param.ParameterType.FullyQualifiedName}){ArgsVarName}[{param.ParameterIndex}]", // None or In (in doesn't require keyword at call site)
+                    };
+                }
             }
 
             private static string? GetPrimitiveWriterMethod(TypeGenerationSpec type)

src/libraries/System.Text.Json/gen/JsonSourceGenerator.Parser.cs

@@ -1515,6 +1515,7 @@ private void ProcessMember(
                             DefaultValue = parameterInfo.HasExplicitDefaultValue ? parameterInfo.ExplicitDefaultValue : null,
                             ParameterIndex = i,
                             IsNullable = parameterInfo.IsNullable(),
+                            RefKind = (int)parameterInfo.RefKind,
                         };
                     }
                 }

src/libraries/System.Text.Json/gen/Model/ParameterGenerationSpec.cs

@@ -33,5 +33,11 @@ public sealed record ParameterGenerationSpec
         public required object? DefaultValue { get; init; }
         public required int ParameterIndex { get; init; }
         public required bool IsNullable { get; init; }
+
+        /// <summary>
+        /// The ref kind of the parameter: None (0), Ref (1), Out (2), In (3), RefReadOnlyParameter (4).
+        /// Using int instead of Microsoft.CodeAnalysis.RefKind to avoid dependency issues.
+        /// </summary>
+        public required int RefKind { get; init; }
     }
 }

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);