Extend detection for unsupported types

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

@@ -101,7 +101,7 @@ private sealed class Parser
 
  // Unsupported types
  private readonly Type _delegateType;
- private readonly Type _typeType;
+ private readonly Type _memberInfoType;
  private readonly Type _serializationInfoType;
  private readonly Type _intPtrType;
  private readonly Type _uIntPtrType;
@@ -232,15 +232,15 @@ public Parser(Compilation compilation, in JsonSourceGenerationContext sourceGene
  _jsonObjectType = _metadataLoadContext.Resolve(JsonObjectFullName);
  _jsonValueType = _metadataLoadContext.Resolve(JsonValueFullName);
  _jsonDocumentType = _metadataLoadContext.Resolve(JsonDocumentFullName);
+ _dateOnlyType = _metadataLoadContext.Resolve(DateOnlyFullName);
+ _timeOnlyType = _metadataLoadContext.Resolve(TimeOnlyFullName);
 
  // Unsupported types.
  _delegateType = _metadataLoadContext.Resolve(SpecialType.System_Delegate);
-_typeType = _metadataLoadContext.Resolve(typeof(Type));
+_memberInfoType = _metadataLoadContext.Resolve(typeof(MemberInfo));
  _serializationInfoType = _metadataLoadContext.Resolve(typeof(Runtime.Serialization.SerializationInfo));
  _intPtrType = _metadataLoadContext.Resolve(typeof(IntPtr));
  _uIntPtrType = _metadataLoadContext.Resolve(typeof(UIntPtr));
- _dateOnlyType = _metadataLoadContext.Resolve(DateOnlyFullName);
- _timeOnlyType = _metadataLoadContext.Resolve(TimeOnlyFullName);
 
  _jsonConverterOfTType = _metadataLoadContext.Resolve(JsonConverterOfTFullName);
 
@@ -960,7 +960,10 @@ private TypeGenerationSpec GetOrAddTypeGenerationSpec(Type type, JsonSourceGener
  }
  }
  }
- else if (_knownUnsupportedTypes.Contains(type) || _delegateType.IsAssignableFrom(type))
+ else if (
+ _knownUnsupportedTypes.Contains(type) ||
+ _memberInfoType.IsAssignableFrom(type) ||
+ _delegateType.IsAssignableFrom(type))
  {
  classType = ClassType.KnownUnsupportedType;
  }
@@ -1590,7 +1593,6 @@ private void PopulateKnownTypes()
  AddTypeIfNotNull(_knownTypes, _jsonValueType);
  AddTypeIfNotNull(_knownTypes, _jsonDocumentType);
 
- _knownUnsupportedTypes.Add(_typeType);
  _knownUnsupportedTypes.Add(_serializationInfoType);
  _knownUnsupportedTypes.Add(_intPtrType);
  _knownUnsupportedTypes.Add(_uIntPtrType);

src/libraries/System.Text.Json/gen/Reflection/TypeWrapper.cs

@@ -595,17 +595,11 @@ protected override bool IsPrimitiveImpl()
 
  public override bool IsAssignableFrom(Type c)
  {
- if (c is TypeWrapper tr)
- {
- return tr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
- (tr._namedTypeSymbol != null && tr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default));
- }
- else if (_metadataLoadContext.Resolve(c) is TypeWrapper trr)
- {
- return trr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
- (trr._namedTypeSymbol != null && trr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default));
- }
- return false;
+ TypeWrapper? tr = c as TypeWrapper ?? _metadataLoadContext.Resolve(c) as TypeWrapper;
+
+ return tr is not null &&
+ (tr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
+ (tr._namedTypeSymbol != null && tr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default)));
  }
 
 #pragma warning disable RS1024 // Compare symbols correctly

src/libraries/System.Text.Json/src/Resources/Strings.resx

@@ -518,6 +518,9 @@
  <data name="CannotPopulateCollection" xml:space="preserve">
  <value>The collection type '{0}' is abstract, an interface, or is read only, and could not be instantiated and populated.</value>
  </data>
+ <data name="ConstructorContainsNullParameterNames" xml:space="preserve">
+ <value>The deserialization constructor for type '{0}' contains parameters with null names. This might happen because the parameter names have been trimmed by the linker. Consider using the source generated serializer instead.</value>
+ </data>
  <data name="DefaultIgnoreConditionAlreadySpecified" xml:space="preserve">
  <value>'IgnoreNullValues' and 'DefaultIgnoreCondition' cannot both be set to non-default values.</value>
  </data>

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/UnsupportedTypeConverterFactory.cs

@@ -15,8 +15,8 @@ public override bool CanConvert(Type type)
  // If a type is added, also add to the SourceGeneration project.
 
  return
- // There's no safe way to construct a Type from untrusted user input.
- typeof(Type).IsAssignableFrom(type) ||
+ // There's no safe way to construct a Type/MemberInfo from untrusted user input.
+ typeof(MemberInfo).IsAssignableFrom(type) ||
  // (De)serialization of SerializationInfo is already disallowed due to Type being disallowed
  // (the two ctors on SerializationInfo take a Type, and a Type member is present when serializing).
  // Explicitly disallowing this type provides a clear exception when ctors with

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

@@ -230,22 +230,25 @@ private static bool PropertyIsOverriddenAndIgnored(
 
  internal override JsonParameterInfoValues[] GetParameterInfoValues()
  {
- ParameterInfo[] parameters = Converter.ConstructorInfo!.GetParameters();
- return GetParameterInfoArray(parameters);
- }
-
- private static JsonParameterInfoValues[] GetParameterInfoArray(ParameterInfo[] parameters)
- {
+ Debug.Assert(Converter.ConstructorInfo != null);
+ ParameterInfo[] parameters = Converter.ConstructorInfo.GetParameters();
  int parameterCount = parameters.Length;
  JsonParameterInfoValues[] jsonParameters = new JsonParameterInfoValues[parameterCount];
 
  for (int i = 0; i < parameterCount; i++)
  {
  ParameterInfo reflectionInfo = parameters[i];
 
+ // Trimmed parameter names are reported as null in CoreCLR or "" in Mono.
+ if (string.IsNullOrEmpty(reflectionInfo.Name))
+ {
+ Debug.Assert(Converter.ConstructorInfo.DeclaringType != null);
+ ThrowHelper.ThrowNotSupportedException_BaseConverterDoesNotSupportMetadata(Converter.ConstructorInfo.DeclaringType);
+ }
+
  JsonParameterInfoValues jsonInfo = new()
  {
- Name = reflectionInfo.Name!,
+ Name = reflectionInfo.Name,
  ParameterType = reflectionInfo.ParameterType,
  Position = reflectionInfo.Position,
  HasDefaultValue = reflectionInfo.HasDefaultValue,

src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs

@@ -709,6 +709,13 @@ public static void ThrowNotSupportedException_NoMetadataForType(Type type, IJson
  throw new NotSupportedException(SR.Format(SR.NoMetadataForType, type, resolver?.GetType().FullName ?? "<null>"));
  }
 
+
+ [DoesNotReturn]
+ public static void ThrowNotSupportedException_ConstructorContainsNullParameterNames(Type declaringType)
+ {
+ throw new NotSupportedException(SR.Format(SR.ConstructorContainsNullParameterNames, declaringType));
+ }
+
  [DoesNotReturn]
  public static void ThrowInvalidOperationException_NoMetadataForType(Type type, IJsonTypeInfoResolver? resolver)
  {

src/libraries/System.Text.Json/tests/Common/UnsupportedTypesTests.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
+using System.Reflection;
 using System.Runtime.Serialization;
 using System.Threading;
 using System.Threading.Tasks;
@@ -20,110 +21,117 @@ public UnsupportedTypesTests(
  SupportsJsonPathOnSerialize = supportsJsonPathOnSerialize;
  }
 
- [Fact]
- public async Task DeserializeUnsupportedType()
+ [Theory]
+ [MemberData(nameof(GetUnsupportedValues))]
+ public async Task DeserializeUnsupportedType<T>(ValueWrapper<T> wrapper)
  {
- // Any test payload is fine.
- string json = @"""Some string""";
+ _ = wrapper; // only used to instantiate T
 
- await RunTest<Type>(json);
- await RunTest<SerializationInfo>(json);
- await RunTest<IntPtr>(json);
- await RunTest<IntPtr?>(json); // One nullable variation.
- await RunTest<UIntPtr>(json);
+ string json = @"""Some string"""; // Any test payload is fine.
 
- async Task RunTest<T>(string json)
- {
- Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
- string fullName = type.FullName;
+ Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
+ string fullName = type.FullName;
 
-NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<T>(json));
-string exAsStr = ex.ToString();
-Assert.Contains(fullName, exAsStr);
-Assert.Contains("$", exAsStr);
+ NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<T>(json));
+ string exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$", exAsStr);
 
-json = $@"{{""Prop"":{json}}}";
+ json = $@"{{""Prop"":{json}}}";
 
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<ClassWithType<T>>(json));
-exAsStr = ex.ToString();
-Assert.Contains(fullName, exAsStr);
-Assert.Contains("$.Prop", exAsStr);
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<ClassWithType<T>>(json));
+ exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$.Prop", exAsStr);
 
-// Verify Nullable<> semantics. NSE is not thrown because the serializer handles null.
-if (isNullableOfT)
-{
-Assert.Null(JsonSerializer.Deserialize<T>("null"));
+ // Verify Nullable<> semantics. NSE is not thrown because the serializer handles null.
+ if (isNullableOfT)
+ {
+ Assert.Null(JsonSerializer.Deserialize<T>("null"));
 
- json = $@"{{""Prop"":null}}";
- ClassWithType<T> obj = await Serializer.DeserializeWrapper<ClassWithType<T>>(json);
- Assert.Null(obj.Prop);
- }
+ json = $@"{{""Prop"":null}}";
+ ClassWithType<T> obj = await Serializer.DeserializeWrapper<ClassWithType<T>>(json);
+ Assert.Null(obj.Prop);
  }
  }
 
- [Fact]
- public async Task SerializeUnsupportedType()
+ [Theory]
+ [MemberData(nameof(GetUnsupportedValues))]
+ public async Task SerializeUnsupportedType<T>(ValueWrapper<T> wrapper)
  {
- // TODO refactor to Xunit theory
- await RunTest(typeof(int));
- await RunTest(new SerializationInfo(typeof(Type), new FormatterConverter()));
- await RunTest((IntPtr)123);
- await RunTest<IntPtr?>(new IntPtr(123)); // One nullable variation.
- await RunTest((UIntPtr)123);
-
- async Task RunTest<T>(T value)
+ T value = wrapper.value;
+
+ Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
+ string fullName = type.FullName;
+
+ NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(value));
+ string exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$", exAsStr);
+
+ ClassWithType<T> obj = new ClassWithType<T> { Prop = value };
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(obj));
+ exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+
+ if (SupportsJsonPathOnSerialize)
+ {
+ Assert.Contains("$.Prop", exAsStr);
+ }
+ else
  {
- Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
- string fullName = type.FullName;
-
- NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(value));
- string exAsStr = ex.ToString();
- Assert.Contains(fullName, exAsStr);
- Assert.Contains("$", exAsStr);
-
- ClassWithType<T> obj = new ClassWithType<T> { Prop = value };
- ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(obj));
- exAsStr = ex.ToString();
- Assert.Contains(fullName, exAsStr);
-
- if (SupportsJsonPathOnSerialize)
- {
- Assert.Contains("$.Prop", exAsStr);
- }
- else
- {
- Assert.Contains("$.", exAsStr);
- Assert.DoesNotContain("$.Prop", exAsStr);
- }
-
- // Verify null semantics. NSE is not thrown because the serializer handles null.
- if (!type.IsValueType || isNullableOfT)
- {
- string serialized = await Serializer.SerializeWrapper<T>((T)(object)null);
- Assert.Equal("null", serialized);
-
- obj.Prop = (T)(object)null;
- serialized = await Serializer.SerializeWrapper(obj);
- Assert.Equal(@"{""Prop"":null}", serialized);
-
- serialized = await Serializer.SerializeWrapper(obj, new JsonSerializerOptions { IgnoreNullValues = true });
- Assert.Equal(@"{}", serialized);
- }
+ Assert.Contains("$.", exAsStr);
+ Assert.DoesNotContain("$.Prop", exAsStr);
+ }
+
+ // Verify null semantics. NSE is not thrown because the serializer handles null.
+ if (!type.IsValueType || isNullableOfT)
+ {
+ string serialized = await Serializer.SerializeWrapper<T>((T)(object)null);
+ Assert.Equal("null", serialized);
+
+ obj.Prop = (T)(object)null;
+ serialized = await Serializer.SerializeWrapper(obj);
+ Assert.Equal(@"{""Prop"":null}", serialized);
+
+ serialized = await Serializer.SerializeWrapper(obj, new JsonSerializerOptions { IgnoreNullValues = true });
+ Assert.Equal(@"{}", serialized);
+ }
 
 #if !BUILDING_SOURCE_GENERATOR_TESTS
-Type runtimeType = GetNullableOfTUnderlyingType(value.GetType(), out bool _);
+ Type runtimeType = GetNullableOfTUnderlyingType(value.GetType(), out bool _);
 
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper<object>(value));
-exAsStr = ex.ToString();
-Assert.Contains(runtimeType.FullName, exAsStr);
-Assert.Contains("$", exAsStr);
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper<object>(value));
+ exAsStr = ex.ToString();
+ Assert.Contains(runtimeType.FullName, exAsStr);
+ Assert.Contains("$", exAsStr);
 
-ClassWithType<object> polyObj = new ClassWithType<object> { Prop = value };
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(polyObj));
-exAsStr = ex.ToString();
-Assert.Contains(runtimeType.FullName, exAsStr);
+ ClassWithType<object> polyObj = new ClassWithType<object> { Prop = value };
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(polyObj));
+ exAsStr = ex.ToString();
+ Assert.Contains(runtimeType.FullName, exAsStr);
 #endif
- }
+ }
+
+ public static IEnumerable<object[]> GetUnsupportedValues()
+ {
+ yield return WrapArgs(typeof(int));
+ yield return WrapArgs(typeof(ClassWithExtensionProperty).GetConstructor(Array.Empty<Type>()));
+ yield return WrapArgs(typeof(ClassWithExtensionProperty).GetProperty(nameof(ClassWithExtensionProperty.MyInt)));
+ yield return WrapArgs(new SerializationInfo(typeof(Type), new FormatterConverter()));
+ yield return WrapArgs((IntPtr)123);
+ yield return WrapArgs<IntPtr?>(new IntPtr(123)); // One nullable variation.
+ yield return WrapArgs((UIntPtr)123);
+
+ static object[] WrapArgs<T>(T value) => new object[] { new ValueWrapper<T>(value) };
+ }
+
+ // Helper record used to path both value & type information to generic theories.
+ // This is needed e.g. when passing System.Type instances whose runtime type
+ // actually is System.Reflection.RuntimeType.
+ public record ValueWrapper<T>(T value)
+ {
+ public override string ToString() => value.ToString();
  }
 
  public class ClassWithIntPtr
@@ -151,6 +159,21 @@ public override void Write(Utf8JsonWriter writer, IntPtr value, JsonSerializerOp
  }
  }
 
+#if !BUILDING_SOURCE_GENERATOR_TESTS
+ [Fact]
+ public async Task TypeWithNullConstructorParameterName_ThrowsNotSupportedException()
+ {
+ // Regression test for https://github.com/dotnet/runtime/issues/58690
+ Type type = Assembly.GetExecutingAssembly().GetType("System.Runtime.CompilerServices.NullableContextAttribute")!;
+ ConstructorInfo ctorInfo = type.GetConstructor(new Type[] { typeof(byte) });
+ Assert.True(string.IsNullOrEmpty(ctorInfo.GetParameters()[0].Name));
+ object value = ctorInfo.Invoke(new object[] { (byte)0 });
+
+ await Assert.ThrowsAnyAsync<NotSupportedException>(() => Serializer.SerializeWrapper(value));
+ await Assert.ThrowsAnyAsync<NotSupportedException>(() => Serializer.DeserializeWrapper("{}", type));
+ }
+#endif
+
  [Fact]
  public async Task RuntimeConverterIsSupported_IntPtr()
  {

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

@@ -101,7 +101,7 @@ private sealed class Parser
 
  // Unsupported types
  private readonly Type _delegateType;
- private readonly Type _typeType;
+ private readonly Type _memberInfoType;
  private readonly Type _serializationInfoType;
  private readonly Type _intPtrType;
  private readonly Type _uIntPtrType;
@@ -232,15 +232,15 @@ public Parser(Compilation compilation, in JsonSourceGenerationContext sourceGene
  _jsonObjectType = _metadataLoadContext.Resolve(JsonObjectFullName);
  _jsonValueType = _metadataLoadContext.Resolve(JsonValueFullName);
  _jsonDocumentType = _metadataLoadContext.Resolve(JsonDocumentFullName);
+ _dateOnlyType = _metadataLoadContext.Resolve(DateOnlyFullName);
+ _timeOnlyType = _metadataLoadContext.Resolve(TimeOnlyFullName);
 
  // Unsupported types.
  _delegateType = _metadataLoadContext.Resolve(SpecialType.System_Delegate);
-_typeType = _metadataLoadContext.Resolve(typeof(Type));
+_memberInfoType = _metadataLoadContext.Resolve(typeof(MemberInfo));
  _serializationInfoType = _metadataLoadContext.Resolve(typeof(Runtime.Serialization.SerializationInfo));
  _intPtrType = _metadataLoadContext.Resolve(typeof(IntPtr));
  _uIntPtrType = _metadataLoadContext.Resolve(typeof(UIntPtr));
- _dateOnlyType = _metadataLoadContext.Resolve(DateOnlyFullName);
- _timeOnlyType = _metadataLoadContext.Resolve(TimeOnlyFullName);
 
  _jsonConverterOfTType = _metadataLoadContext.Resolve(JsonConverterOfTFullName);
 
@@ -960,7 +960,10 @@ private TypeGenerationSpec GetOrAddTypeGenerationSpec(Type type, JsonSourceGener
  }
  }
  }
- else if (_knownUnsupportedTypes.Contains(type) || _delegateType.IsAssignableFrom(type))
+ else if (
+ _knownUnsupportedTypes.Contains(type) ||
+ _memberInfoType.IsAssignableFrom(type) ||
+ _delegateType.IsAssignableFrom(type))
  {
  classType = ClassType.KnownUnsupportedType;
  }
@@ -1590,7 +1593,6 @@ private void PopulateKnownTypes()
  AddTypeIfNotNull(_knownTypes, _jsonValueType);
  AddTypeIfNotNull(_knownTypes, _jsonDocumentType);
 
- _knownUnsupportedTypes.Add(_typeType);
  _knownUnsupportedTypes.Add(_serializationInfoType);
  _knownUnsupportedTypes.Add(_intPtrType);
  _knownUnsupportedTypes.Add(_uIntPtrType);

src/libraries/System.Text.Json/gen/Reflection/TypeWrapper.cs

@@ -595,17 +595,11 @@ protected override bool IsPrimitiveImpl()
 
  public override bool IsAssignableFrom(Type c)
  {
- if (c is TypeWrapper tr)
- {
- return tr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
- (tr._namedTypeSymbol != null && tr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default));
- }
- else if (_metadataLoadContext.Resolve(c) is TypeWrapper trr)
- {
- return trr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
- (trr._namedTypeSymbol != null && trr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default));
- }
- return false;
+ TypeWrapper? tr = c as TypeWrapper ?? _metadataLoadContext.Resolve(c) as TypeWrapper;
+
+ return tr is not null &&
+ (tr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
+ (tr._namedTypeSymbol != null && tr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default)));
  }
 
 #pragma warning disable RS1024 // Compare symbols correctly

src/libraries/System.Text.Json/src/Resources/Strings.resx

@@ -518,6 +518,9 @@
  <data name="CannotPopulateCollection" xml:space="preserve">
  <value>The collection type '{0}' is abstract, an interface, or is read only, and could not be instantiated and populated.</value>
  </data>
+ <data name="ConstructorContainsNullParameterNames" xml:space="preserve">
+ <value>The deserialization constructor for type '{0}' contains parameters with null names. This might happen because the parameter names have been trimmed by the linker. Consider using the source generated serializer instead.</value>
+ </data>
  <data name="DefaultIgnoreConditionAlreadySpecified" xml:space="preserve">
  <value>'IgnoreNullValues' and 'DefaultIgnoreCondition' cannot both be set to non-default values.</value>
  </data>

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/UnsupportedTypeConverterFactory.cs

@@ -15,8 +15,8 @@ public override bool CanConvert(Type type)
  // If a type is added, also add to the SourceGeneration project.
 
  return
- // There's no safe way to construct a Type from untrusted user input.
- typeof(Type).IsAssignableFrom(type) ||
+ // There's no safe way to construct a Type/MemberInfo from untrusted user input.
+ typeof(MemberInfo).IsAssignableFrom(type) ||
  // (De)serialization of SerializationInfo is already disallowed due to Type being disallowed
  // (the two ctors on SerializationInfo take a Type, and a Type member is present when serializing).
  // Explicitly disallowing this type provides a clear exception when ctors with

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

@@ -230,22 +230,25 @@ private static bool PropertyIsOverriddenAndIgnored(
 
  internal override JsonParameterInfoValues[] GetParameterInfoValues()
  {
- ParameterInfo[] parameters = Converter.ConstructorInfo!.GetParameters();
- return GetParameterInfoArray(parameters);
- }
-
- private static JsonParameterInfoValues[] GetParameterInfoArray(ParameterInfo[] parameters)
- {
+ Debug.Assert(Converter.ConstructorInfo != null);
+ ParameterInfo[] parameters = Converter.ConstructorInfo.GetParameters();
  int parameterCount = parameters.Length;
  JsonParameterInfoValues[] jsonParameters = new JsonParameterInfoValues[parameterCount];
 
  for (int i = 0; i < parameterCount; i++)
  {
  ParameterInfo reflectionInfo = parameters[i];
 
+ // Trimmed parameter names are reported as null in CoreCLR or "" in Mono.
+ if (string.IsNullOrEmpty(reflectionInfo.Name))
+ {
+ Debug.Assert(Converter.ConstructorInfo.DeclaringType != null);
+ ThrowHelper.ThrowNotSupportedException_BaseConverterDoesNotSupportMetadata(Converter.ConstructorInfo.DeclaringType);
+ }
+
  JsonParameterInfoValues jsonInfo = new()
  {
- Name = reflectionInfo.Name!,
+ Name = reflectionInfo.Name,
  ParameterType = reflectionInfo.ParameterType,
  Position = reflectionInfo.Position,
  HasDefaultValue = reflectionInfo.HasDefaultValue,

src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs

@@ -709,6 +709,13 @@ public static void ThrowNotSupportedException_NoMetadataForType(Type type, IJson
  throw new NotSupportedException(SR.Format(SR.NoMetadataForType, type, resolver?.GetType().FullName ?? "<null>"));
  }
 
+
+ [DoesNotReturn]
+ public static void ThrowNotSupportedException_ConstructorContainsNullParameterNames(Type declaringType)
+ {
+ throw new NotSupportedException(SR.Format(SR.ConstructorContainsNullParameterNames, declaringType));
+ }
+
  [DoesNotReturn]
  public static void ThrowInvalidOperationException_NoMetadataForType(Type type, IJsonTypeInfoResolver? resolver)
  {

src/libraries/System.Text.Json/tests/Common/UnsupportedTypesTests.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
+using System.Reflection;
 using System.Runtime.Serialization;
 using System.Threading;
 using System.Threading.Tasks;
@@ -20,110 +21,117 @@ public UnsupportedTypesTests(
  SupportsJsonPathOnSerialize = supportsJsonPathOnSerialize;
  }
 
- [Fact]
- public async Task DeserializeUnsupportedType()
+ [Theory]
+ [MemberData(nameof(GetUnsupportedValues))]
+ public async Task DeserializeUnsupportedType<T>(ValueWrapper<T> wrapper)
  {
- // Any test payload is fine.
- string json = @"""Some string""";
+ _ = wrapper; // only used to instantiate T
 
- await RunTest<Type>(json);
- await RunTest<SerializationInfo>(json);
- await RunTest<IntPtr>(json);
- await RunTest<IntPtr?>(json); // One nullable variation.
- await RunTest<UIntPtr>(json);
+ string json = @"""Some string"""; // Any test payload is fine.
 
- async Task RunTest<T>(string json)
- {
- Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
- string fullName = type.FullName;
+ Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
+ string fullName = type.FullName;
 
-NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<T>(json));
-string exAsStr = ex.ToString();
-Assert.Contains(fullName, exAsStr);
-Assert.Contains("$", exAsStr);
+ NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<T>(json));
+ string exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$", exAsStr);
 
-json = $@"{{""Prop"":{json}}}";
+ json = $@"{{""Prop"":{json}}}";
 
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<ClassWithType<T>>(json));
-exAsStr = ex.ToString();
-Assert.Contains(fullName, exAsStr);
-Assert.Contains("$.Prop", exAsStr);
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<ClassWithType<T>>(json));
+ exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$.Prop", exAsStr);
 
-// Verify Nullable<> semantics. NSE is not thrown because the serializer handles null.
-if (isNullableOfT)
-{
-Assert.Null(JsonSerializer.Deserialize<T>("null"));
+ // Verify Nullable<> semantics. NSE is not thrown because the serializer handles null.
+ if (isNullableOfT)
+ {
+ Assert.Null(JsonSerializer.Deserialize<T>("null"));
 
- json = $@"{{""Prop"":null}}";
- ClassWithType<T> obj = await Serializer.DeserializeWrapper<ClassWithType<T>>(json);
- Assert.Null(obj.Prop);
- }
+ json = $@"{{""Prop"":null}}";
+ ClassWithType<T> obj = await Serializer.DeserializeWrapper<ClassWithType<T>>(json);
+ Assert.Null(obj.Prop);
  }
  }
 
- [Fact]
- public async Task SerializeUnsupportedType()
+ [Theory]
+ [MemberData(nameof(GetUnsupportedValues))]
+ public async Task SerializeUnsupportedType<T>(ValueWrapper<T> wrapper)
  {
- // TODO refactor to Xunit theory
- await RunTest(typeof(int));
- await RunTest(new SerializationInfo(typeof(Type), new FormatterConverter()));
- await RunTest((IntPtr)123);
- await RunTest<IntPtr?>(new IntPtr(123)); // One nullable variation.
- await RunTest((UIntPtr)123);
-
- async Task RunTest<T>(T value)
+ T value = wrapper.value;
+
+ Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
+ string fullName = type.FullName;
+
+ NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(value));
+ string exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$", exAsStr);
+
+ ClassWithType<T> obj = new ClassWithType<T> { Prop = value };
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(obj));
+ exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+
+ if (SupportsJsonPathOnSerialize)
+ {
+ Assert.Contains("$.Prop", exAsStr);
+ }
+ else
  {
- Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
- string fullName = type.FullName;
-
- NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(value));
- string exAsStr = ex.ToString();
- Assert.Contains(fullName, exAsStr);
- Assert.Contains("$", exAsStr);
-
- ClassWithType<T> obj = new ClassWithType<T> { Prop = value };
- ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(obj));
- exAsStr = ex.ToString();
- Assert.Contains(fullName, exAsStr);
-
- if (SupportsJsonPathOnSerialize)
- {
- Assert.Contains("$.Prop", exAsStr);
- }
- else
- {
- Assert.Contains("$.", exAsStr);
- Assert.DoesNotContain("$.Prop", exAsStr);
- }
-
- // Verify null semantics. NSE is not thrown because the serializer handles null.
- if (!type.IsValueType || isNullableOfT)
- {
- string serialized = await Serializer.SerializeWrapper<T>((T)(object)null);
- Assert.Equal("null", serialized);
-
- obj.Prop = (T)(object)null;
- serialized = await Serializer.SerializeWrapper(obj);
- Assert.Equal(@"{""Prop"":null}", serialized);
-
- serialized = await Serializer.SerializeWrapper(obj, new JsonSerializerOptions { IgnoreNullValues = true });
- Assert.Equal(@"{}", serialized);
- }
+ Assert.Contains("$.", exAsStr);
+ Assert.DoesNotContain("$.Prop", exAsStr);
+ }
+
+ // Verify null semantics. NSE is not thrown because the serializer handles null.
+ if (!type.IsValueType || isNullableOfT)
+ {
+ string serialized = await Serializer.SerializeWrapper<T>((T)(object)null);
+ Assert.Equal("null", serialized);
+
+ obj.Prop = (T)(object)null;
+ serialized = await Serializer.SerializeWrapper(obj);
+ Assert.Equal(@"{""Prop"":null}", serialized);
+
+ serialized = await Serializer.SerializeWrapper(obj, new JsonSerializerOptions { IgnoreNullValues = true });
+ Assert.Equal(@"{}", serialized);
+ }
 
 #if !BUILDING_SOURCE_GENERATOR_TESTS
-Type runtimeType = GetNullableOfTUnderlyingType(value.GetType(), out bool _);
+ Type runtimeType = GetNullableOfTUnderlyingType(value.GetType(), out bool _);
 
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper<object>(value));
-exAsStr = ex.ToString();
-Assert.Contains(runtimeType.FullName, exAsStr);
-Assert.Contains("$", exAsStr);
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper<object>(value));
+ exAsStr = ex.ToString();
+ Assert.Contains(runtimeType.FullName, exAsStr);
+ Assert.Contains("$", exAsStr);
 
-ClassWithType<object> polyObj = new ClassWithType<object> { Prop = value };
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(polyObj));
-exAsStr = ex.ToString();
-Assert.Contains(runtimeType.FullName, exAsStr);
+ ClassWithType<object> polyObj = new ClassWithType<object> { Prop = value };
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(polyObj));
+ exAsStr = ex.ToString();
+ Assert.Contains(runtimeType.FullName, exAsStr);
 #endif
- }
+ }
+
+ public static IEnumerable<object[]> GetUnsupportedValues()
+ {
+ yield return WrapArgs(typeof(int));
+ yield return WrapArgs(typeof(ClassWithExtensionProperty).GetConstructor(Array.Empty<Type>()));
+ yield return WrapArgs(typeof(ClassWithExtensionProperty).GetProperty(nameof(ClassWithExtensionProperty.MyInt)));
+ yield return WrapArgs(new SerializationInfo(typeof(Type), new FormatterConverter()));
+ yield return WrapArgs((IntPtr)123);
+ yield return WrapArgs<IntPtr?>(new IntPtr(123)); // One nullable variation.
+ yield return WrapArgs((UIntPtr)123);
+
+ static object[] WrapArgs<T>(T value) => new object[] { new ValueWrapper<T>(value) };
+ }
+
+ // Helper record used to path both value & type information to generic theories.
+ // This is needed e.g. when passing System.Type instances whose runtime type
+ // actually is System.Reflection.RuntimeType.
+ public record ValueWrapper<T>(T value)
+ {
+ public override string ToString() => value.ToString();
  }
 
  public class ClassWithIntPtr
@@ -151,6 +159,21 @@ public override void Write(Utf8JsonWriter writer, IntPtr value, JsonSerializerOp
  }
  }
 
+#if !BUILDING_SOURCE_GENERATOR_TESTS
+ [Fact]
+ public async Task TypeWithNullConstructorParameterName_ThrowsNotSupportedException()
+ {
+ // Regression test for https://github.com/dotnet/runtime/issues/58690
+ Type type = Assembly.GetExecutingAssembly().GetType("System.Runtime.CompilerServices.NullableContextAttribute")!;
+ ConstructorInfo ctorInfo = type.GetConstructor(new Type[] { typeof(byte) });
+ Assert.True(string.IsNullOrEmpty(ctorInfo.GetParameters()[0].Name));
+ object value = ctorInfo.Invoke(new object[] { (byte)0 });
+
+ await Assert.ThrowsAnyAsync<NotSupportedException>(() => Serializer.SerializeWrapper(value));
+ await Assert.ThrowsAnyAsync<NotSupportedException>(() => Serializer.DeserializeWrapper("{}", type));
+ }
+#endif
+
  [Fact]
  public async Task RuntimeConverterIsSupported_IntPtr()
  {

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

@@ -101,7 +101,7 @@ private sealed class Parser
 
  // Unsupported types
  private readonly Type _delegateType;
- private readonly Type _typeType;
+ private readonly Type _memberInfoType;
  private readonly Type _serializationInfoType;
  private readonly Type _intPtrType;
  private readonly Type _uIntPtrType;
@@ -232,15 +232,15 @@ public Parser(Compilation compilation, in JsonSourceGenerationContext sourceGene
  _jsonObjectType = _metadataLoadContext.Resolve(JsonObjectFullName);
  _jsonValueType = _metadataLoadContext.Resolve(JsonValueFullName);
  _jsonDocumentType = _metadataLoadContext.Resolve(JsonDocumentFullName);
+ _dateOnlyType = _metadataLoadContext.Resolve(DateOnlyFullName);
+ _timeOnlyType = _metadataLoadContext.Resolve(TimeOnlyFullName);
 
  // Unsupported types.
  _delegateType = _metadataLoadContext.Resolve(SpecialType.System_Delegate);
-_typeType = _metadataLoadContext.Resolve(typeof(Type));
+_memberInfoType = _metadataLoadContext.Resolve(typeof(MemberInfo));
  _serializationInfoType = _metadataLoadContext.Resolve(typeof(Runtime.Serialization.SerializationInfo));
  _intPtrType = _metadataLoadContext.Resolve(typeof(IntPtr));
  _uIntPtrType = _metadataLoadContext.Resolve(typeof(UIntPtr));
- _dateOnlyType = _metadataLoadContext.Resolve(DateOnlyFullName);
- _timeOnlyType = _metadataLoadContext.Resolve(TimeOnlyFullName);
 
  _jsonConverterOfTType = _metadataLoadContext.Resolve(JsonConverterOfTFullName);
 
@@ -960,7 +960,10 @@ private TypeGenerationSpec GetOrAddTypeGenerationSpec(Type type, JsonSourceGener
  }
  }
  }
- else if (_knownUnsupportedTypes.Contains(type) || _delegateType.IsAssignableFrom(type))
+ else if (
+ _knownUnsupportedTypes.Contains(type) ||
+ _memberInfoType.IsAssignableFrom(type) ||
+ _delegateType.IsAssignableFrom(type))
  {
  classType = ClassType.KnownUnsupportedType;
  }
@@ -1590,7 +1593,6 @@ private void PopulateKnownTypes()
  AddTypeIfNotNull(_knownTypes, _jsonValueType);
  AddTypeIfNotNull(_knownTypes, _jsonDocumentType);
 
- _knownUnsupportedTypes.Add(_typeType);
  _knownUnsupportedTypes.Add(_serializationInfoType);
  _knownUnsupportedTypes.Add(_intPtrType);
  _knownUnsupportedTypes.Add(_uIntPtrType);

src/libraries/System.Text.Json/gen/Reflection/TypeWrapper.cs

@@ -595,17 +595,11 @@ protected override bool IsPrimitiveImpl()
 
  public override bool IsAssignableFrom(Type c)
  {
- if (c is TypeWrapper tr)
- {
- return tr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
- (tr._namedTypeSymbol != null && tr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default));
- }
- else if (_metadataLoadContext.Resolve(c) is TypeWrapper trr)
- {
- return trr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
- (trr._namedTypeSymbol != null && trr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default));
- }
- return false;
+ TypeWrapper? tr = c as TypeWrapper ?? _metadataLoadContext.Resolve(c) as TypeWrapper;
+
+ return tr is not null &&
+ (tr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
+ (tr._namedTypeSymbol != null && tr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default)));
  }
 
 #pragma warning disable RS1024 // Compare symbols correctly

src/libraries/System.Text.Json/src/Resources/Strings.resx

@@ -518,6 +518,9 @@
  <data name="CannotPopulateCollection" xml:space="preserve">
  <value>The collection type '{0}' is abstract, an interface, or is read only, and could not be instantiated and populated.</value>
  </data>
+ <data name="ConstructorContainsNullParameterNames" xml:space="preserve">
+ <value>The deserialization constructor for type '{0}' contains parameters with null names. This might happen because the parameter names have been trimmed by the linker. Consider using the source generated serializer instead.</value>
+ </data>
  <data name="DefaultIgnoreConditionAlreadySpecified" xml:space="preserve">
  <value>'IgnoreNullValues' and 'DefaultIgnoreCondition' cannot both be set to non-default values.</value>
  </data>

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/UnsupportedTypeConverterFactory.cs

@@ -15,8 +15,8 @@ public override bool CanConvert(Type type)
  // If a type is added, also add to the SourceGeneration project.
 
  return
- // There's no safe way to construct a Type from untrusted user input.
- typeof(Type).IsAssignableFrom(type) ||
+ // There's no safe way to construct a Type/MemberInfo from untrusted user input.
+ typeof(MemberInfo).IsAssignableFrom(type) ||
  // (De)serialization of SerializationInfo is already disallowed due to Type being disallowed
  // (the two ctors on SerializationInfo take a Type, and a Type member is present when serializing).
  // Explicitly disallowing this type provides a clear exception when ctors with

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

@@ -230,22 +230,25 @@ private static bool PropertyIsOverriddenAndIgnored(
 
  internal override JsonParameterInfoValues[] GetParameterInfoValues()
  {
- ParameterInfo[] parameters = Converter.ConstructorInfo!.GetParameters();
- return GetParameterInfoArray(parameters);
- }
-
- private static JsonParameterInfoValues[] GetParameterInfoArray(ParameterInfo[] parameters)
- {
+ Debug.Assert(Converter.ConstructorInfo != null);
+ ParameterInfo[] parameters = Converter.ConstructorInfo.GetParameters();
  int parameterCount = parameters.Length;
  JsonParameterInfoValues[] jsonParameters = new JsonParameterInfoValues[parameterCount];
 
  for (int i = 0; i < parameterCount; i++)
  {
  ParameterInfo reflectionInfo = parameters[i];
 
+ // Trimmed parameter names are reported as null in CoreCLR or "" in Mono.
+ if (string.IsNullOrEmpty(reflectionInfo.Name))
+ {
+ Debug.Assert(Converter.ConstructorInfo.DeclaringType != null);
+ ThrowHelper.ThrowNotSupportedException_BaseConverterDoesNotSupportMetadata(Converter.ConstructorInfo.DeclaringType);
+ }
+
  JsonParameterInfoValues jsonInfo = new()
  {
- Name = reflectionInfo.Name!,
+ Name = reflectionInfo.Name,
  ParameterType = reflectionInfo.ParameterType,
  Position = reflectionInfo.Position,
  HasDefaultValue = reflectionInfo.HasDefaultValue,

src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs

@@ -709,6 +709,13 @@ public static void ThrowNotSupportedException_NoMetadataForType(Type type, IJson
  throw new NotSupportedException(SR.Format(SR.NoMetadataForType, type, resolver?.GetType().FullName ?? "<null>"));
  }
 
+
+ [DoesNotReturn]
+ public static void ThrowNotSupportedException_ConstructorContainsNullParameterNames(Type declaringType)
+ {
+ throw new NotSupportedException(SR.Format(SR.ConstructorContainsNullParameterNames, declaringType));
+ }
+
  [DoesNotReturn]
  public static void ThrowInvalidOperationException_NoMetadataForType(Type type, IJsonTypeInfoResolver? resolver)
  {

src/libraries/System.Text.Json/tests/Common/UnsupportedTypesTests.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
+using System.Reflection;
 using System.Runtime.Serialization;
 using System.Threading;
 using System.Threading.Tasks;
@@ -20,110 +21,117 @@ public UnsupportedTypesTests(
  SupportsJsonPathOnSerialize = supportsJsonPathOnSerialize;
  }
 
- [Fact]
- public async Task DeserializeUnsupportedType()
+ [Theory]
+ [MemberData(nameof(GetUnsupportedValues))]
+ public async Task DeserializeUnsupportedType<T>(ValueWrapper<T> wrapper)
  {
- // Any test payload is fine.
- string json = @"""Some string""";
+ _ = wrapper; // only used to instantiate T
 
- await RunTest<Type>(json);
- await RunTest<SerializationInfo>(json);
- await RunTest<IntPtr>(json);
- await RunTest<IntPtr?>(json); // One nullable variation.
- await RunTest<UIntPtr>(json);
+ string json = @"""Some string"""; // Any test payload is fine.
 
- async Task RunTest<T>(string json)
- {
- Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
- string fullName = type.FullName;
+ Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
+ string fullName = type.FullName;
 
-NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<T>(json));
-string exAsStr = ex.ToString();
-Assert.Contains(fullName, exAsStr);
-Assert.Contains("$", exAsStr);
+ NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<T>(json));
+ string exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$", exAsStr);
 
-json = $@"{{""Prop"":{json}}}";
+ json = $@"{{""Prop"":{json}}}";
 
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<ClassWithType<T>>(json));
-exAsStr = ex.ToString();
-Assert.Contains(fullName, exAsStr);
-Assert.Contains("$.Prop", exAsStr);
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<ClassWithType<T>>(json));
+ exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$.Prop", exAsStr);
 
-// Verify Nullable<> semantics. NSE is not thrown because the serializer handles null.
-if (isNullableOfT)
-{
-Assert.Null(JsonSerializer.Deserialize<T>("null"));
+ // Verify Nullable<> semantics. NSE is not thrown because the serializer handles null.
+ if (isNullableOfT)
+ {
+ Assert.Null(JsonSerializer.Deserialize<T>("null"));
 
- json = $@"{{""Prop"":null}}";
- ClassWithType<T> obj = await Serializer.DeserializeWrapper<ClassWithType<T>>(json);
- Assert.Null(obj.Prop);
- }
+ json = $@"{{""Prop"":null}}";
+ ClassWithType<T> obj = await Serializer.DeserializeWrapper<ClassWithType<T>>(json);
+ Assert.Null(obj.Prop);
  }
  }
 
- [Fact]
- public async Task SerializeUnsupportedType()
+ [Theory]
+ [MemberData(nameof(GetUnsupportedValues))]
+ public async Task SerializeUnsupportedType<T>(ValueWrapper<T> wrapper)
  {
- // TODO refactor to Xunit theory
- await RunTest(typeof(int));
- await RunTest(new SerializationInfo(typeof(Type), new FormatterConverter()));
- await RunTest((IntPtr)123);
- await RunTest<IntPtr?>(new IntPtr(123)); // One nullable variation.
- await RunTest((UIntPtr)123);
-
- async Task RunTest<T>(T value)
+ T value = wrapper.value;
+
+ Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
+ string fullName = type.FullName;
+
+ NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(value));
+ string exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$", exAsStr);
+
+ ClassWithType<T> obj = new ClassWithType<T> { Prop = value };
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(obj));
+ exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+
+ if (SupportsJsonPathOnSerialize)
+ {
+ Assert.Contains("$.Prop", exAsStr);
+ }
+ else
  {
- Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
- string fullName = type.FullName;
-
- NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(value));
- string exAsStr = ex.ToString();
- Assert.Contains(fullName, exAsStr);
- Assert.Contains("$", exAsStr);
-
- ClassWithType<T> obj = new ClassWithType<T> { Prop = value };
- ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(obj));
- exAsStr = ex.ToString();
- Assert.Contains(fullName, exAsStr);
-
- if (SupportsJsonPathOnSerialize)
- {
- Assert.Contains("$.Prop", exAsStr);
- }
- else
- {
- Assert.Contains("$.", exAsStr);
- Assert.DoesNotContain("$.Prop", exAsStr);
- }
-
- // Verify null semantics. NSE is not thrown because the serializer handles null.
- if (!type.IsValueType || isNullableOfT)
- {
- string serialized = await Serializer.SerializeWrapper<T>((T)(object)null);
- Assert.Equal("null", serialized);
-
- obj.Prop = (T)(object)null;
- serialized = await Serializer.SerializeWrapper(obj);
- Assert.Equal(@"{""Prop"":null}", serialized);
-
- serialized = await Serializer.SerializeWrapper(obj, new JsonSerializerOptions { IgnoreNullValues = true });
- Assert.Equal(@"{}", serialized);
- }
+ Assert.Contains("$.", exAsStr);
+ Assert.DoesNotContain("$.Prop", exAsStr);
+ }
+
+ // Verify null semantics. NSE is not thrown because the serializer handles null.
+ if (!type.IsValueType || isNullableOfT)
+ {
+ string serialized = await Serializer.SerializeWrapper<T>((T)(object)null);
+ Assert.Equal("null", serialized);
+
+ obj.Prop = (T)(object)null;
+ serialized = await Serializer.SerializeWrapper(obj);
+ Assert.Equal(@"{""Prop"":null}", serialized);
+
+ serialized = await Serializer.SerializeWrapper(obj, new JsonSerializerOptions { IgnoreNullValues = true });
+ Assert.Equal(@"{}", serialized);
+ }
 
 #if !BUILDING_SOURCE_GENERATOR_TESTS
-Type runtimeType = GetNullableOfTUnderlyingType(value.GetType(), out bool _);
+ Type runtimeType = GetNullableOfTUnderlyingType(value.GetType(), out bool _);
 
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper<object>(value));
-exAsStr = ex.ToString();
-Assert.Contains(runtimeType.FullName, exAsStr);
-Assert.Contains("$", exAsStr);
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper<object>(value));
+ exAsStr = ex.ToString();
+ Assert.Contains(runtimeType.FullName, exAsStr);
+ Assert.Contains("$", exAsStr);
 
-ClassWithType<object> polyObj = new ClassWithType<object> { Prop = value };
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(polyObj));
-exAsStr = ex.ToString();
-Assert.Contains(runtimeType.FullName, exAsStr);
+ ClassWithType<object> polyObj = new ClassWithType<object> { Prop = value };
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(polyObj));
+ exAsStr = ex.ToString();
+ Assert.Contains(runtimeType.FullName, exAsStr);
 #endif
- }
+ }
+
+ public static IEnumerable<object[]> GetUnsupportedValues()
+ {
+ yield return WrapArgs(typeof(int));
+ yield return WrapArgs(typeof(ClassWithExtensionProperty).GetConstructor(Array.Empty<Type>()));
+ yield return WrapArgs(typeof(ClassWithExtensionProperty).GetProperty(nameof(ClassWithExtensionProperty.MyInt)));
+ yield return WrapArgs(new SerializationInfo(typeof(Type), new FormatterConverter()));
+ yield return WrapArgs((IntPtr)123);
+ yield return WrapArgs<IntPtr?>(new IntPtr(123)); // One nullable variation.
+ yield return WrapArgs((UIntPtr)123);
+
+ static object[] WrapArgs<T>(T value) => new object[] { new ValueWrapper<T>(value) };
+ }
+
+ // Helper record used to path both value & type information to generic theories.
+ // This is needed e.g. when passing System.Type instances whose runtime type
+ // actually is System.Reflection.RuntimeType.
+ public record ValueWrapper<T>(T value)
+ {
+ public override string ToString() => value.ToString();
  }
 
  public class ClassWithIntPtr
@@ -151,6 +159,21 @@ public override void Write(Utf8JsonWriter writer, IntPtr value, JsonSerializerOp
  }
  }
 
+#if !BUILDING_SOURCE_GENERATOR_TESTS
+ [Fact]
+ public async Task TypeWithNullConstructorParameterName_ThrowsNotSupportedException()
+ {
+ // Regression test for https://github.com/dotnet/runtime/issues/58690
+ Type type = Assembly.GetExecutingAssembly().GetType("System.Runtime.CompilerServices.NullableContextAttribute")!;
+ ConstructorInfo ctorInfo = type.GetConstructor(new Type[] { typeof(byte) });
+ Assert.True(string.IsNullOrEmpty(ctorInfo.GetParameters()[0].Name));
+ object value = ctorInfo.Invoke(new object[] { (byte)0 });
+
+ await Assert.ThrowsAnyAsync<NotSupportedException>(() => Serializer.SerializeWrapper(value));
+ await Assert.ThrowsAnyAsync<NotSupportedException>(() => Serializer.DeserializeWrapper("{}", type));
+ }
+#endif
+
  [Fact]
  public async Task RuntimeConverterIsSupported_IntPtr()
  {

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

@@ -101,7 +101,7 @@ private sealed class Parser
 
  // Unsupported types
  private readonly Type _delegateType;
- private readonly Type _typeType;
+ private readonly Type _memberInfoType;
  private readonly Type _serializationInfoType;
  private readonly Type _intPtrType;
  private readonly Type _uIntPtrType;
@@ -232,15 +232,15 @@ public Parser(Compilation compilation, in JsonSourceGenerationContext sourceGene
  _jsonObjectType = _metadataLoadContext.Resolve(JsonObjectFullName);
  _jsonValueType = _metadataLoadContext.Resolve(JsonValueFullName);
  _jsonDocumentType = _metadataLoadContext.Resolve(JsonDocumentFullName);
+ _dateOnlyType = _metadataLoadContext.Resolve(DateOnlyFullName);
+ _timeOnlyType = _metadataLoadContext.Resolve(TimeOnlyFullName);
 
  // Unsupported types.
  _delegateType = _metadataLoadContext.Resolve(SpecialType.System_Delegate);
-_typeType = _metadataLoadContext.Resolve(typeof(Type));
+_memberInfoType = _metadataLoadContext.Resolve(typeof(MemberInfo));
  _serializationInfoType = _metadataLoadContext.Resolve(typeof(Runtime.Serialization.SerializationInfo));
  _intPtrType = _metadataLoadContext.Resolve(typeof(IntPtr));
  _uIntPtrType = _metadataLoadContext.Resolve(typeof(UIntPtr));
- _dateOnlyType = _metadataLoadContext.Resolve(DateOnlyFullName);
- _timeOnlyType = _metadataLoadContext.Resolve(TimeOnlyFullName);
 
  _jsonConverterOfTType = _metadataLoadContext.Resolve(JsonConverterOfTFullName);
 
@@ -960,7 +960,10 @@ private TypeGenerationSpec GetOrAddTypeGenerationSpec(Type type, JsonSourceGener
  }
  }
  }
- else if (_knownUnsupportedTypes.Contains(type) || _delegateType.IsAssignableFrom(type))
+ else if (
+ _knownUnsupportedTypes.Contains(type) ||
+ _memberInfoType.IsAssignableFrom(type) ||
+ _delegateType.IsAssignableFrom(type))
  {
  classType = ClassType.KnownUnsupportedType;
  }
@@ -1590,7 +1593,6 @@ private void PopulateKnownTypes()
  AddTypeIfNotNull(_knownTypes, _jsonValueType);
  AddTypeIfNotNull(_knownTypes, _jsonDocumentType);
 
- _knownUnsupportedTypes.Add(_typeType);
  _knownUnsupportedTypes.Add(_serializationInfoType);
  _knownUnsupportedTypes.Add(_intPtrType);
  _knownUnsupportedTypes.Add(_uIntPtrType);

src/libraries/System.Text.Json/gen/Reflection/TypeWrapper.cs

@@ -595,17 +595,11 @@ protected override bool IsPrimitiveImpl()
 
  public override bool IsAssignableFrom(Type c)
  {
- if (c is TypeWrapper tr)
- {
- return tr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
- (tr._namedTypeSymbol != null && tr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default));
- }
- else if (_metadataLoadContext.Resolve(c) is TypeWrapper trr)
- {
- return trr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
- (trr._namedTypeSymbol != null && trr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default));
- }
- return false;
+ TypeWrapper? tr = c as TypeWrapper ?? _metadataLoadContext.Resolve(c) as TypeWrapper;
+
+ return tr is not null &&
+ (tr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
+ (tr._namedTypeSymbol != null && tr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default)));
  }
 
 #pragma warning disable RS1024 // Compare symbols correctly

src/libraries/System.Text.Json/src/Resources/Strings.resx

@@ -518,6 +518,9 @@
  <data name="CannotPopulateCollection" xml:space="preserve">
  <value>The collection type '{0}' is abstract, an interface, or is read only, and could not be instantiated and populated.</value>
  </data>
+ <data name="ConstructorContainsNullParameterNames" xml:space="preserve">
+ <value>The deserialization constructor for type '{0}' contains parameters with null names. This might happen because the parameter names have been trimmed by the linker. Consider using the source generated serializer instead.</value>
+ </data>
  <data name="DefaultIgnoreConditionAlreadySpecified" xml:space="preserve">
  <value>'IgnoreNullValues' and 'DefaultIgnoreCondition' cannot both be set to non-default values.</value>
  </data>

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/UnsupportedTypeConverterFactory.cs

@@ -15,8 +15,8 @@ public override bool CanConvert(Type type)
  // If a type is added, also add to the SourceGeneration project.
 
  return
- // There's no safe way to construct a Type from untrusted user input.
- typeof(Type).IsAssignableFrom(type) ||
+ // There's no safe way to construct a Type/MemberInfo from untrusted user input.
+ typeof(MemberInfo).IsAssignableFrom(type) ||
  // (De)serialization of SerializationInfo is already disallowed due to Type being disallowed
  // (the two ctors on SerializationInfo take a Type, and a Type member is present when serializing).
  // Explicitly disallowing this type provides a clear exception when ctors with

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

@@ -230,22 +230,25 @@ private static bool PropertyIsOverriddenAndIgnored(
 
  internal override JsonParameterInfoValues[] GetParameterInfoValues()
  {
- ParameterInfo[] parameters = Converter.ConstructorInfo!.GetParameters();
- return GetParameterInfoArray(parameters);
- }
-
- private static JsonParameterInfoValues[] GetParameterInfoArray(ParameterInfo[] parameters)
- {
+ Debug.Assert(Converter.ConstructorInfo != null);
+ ParameterInfo[] parameters = Converter.ConstructorInfo.GetParameters();
  int parameterCount = parameters.Length;
  JsonParameterInfoValues[] jsonParameters = new JsonParameterInfoValues[parameterCount];
 
  for (int i = 0; i < parameterCount; i++)
  {
  ParameterInfo reflectionInfo = parameters[i];
 
+ // Trimmed parameter names are reported as null in CoreCLR or "" in Mono.
+ if (string.IsNullOrEmpty(reflectionInfo.Name))
+ {
+ Debug.Assert(Converter.ConstructorInfo.DeclaringType != null);
+ ThrowHelper.ThrowNotSupportedException_BaseConverterDoesNotSupportMetadata(Converter.ConstructorInfo.DeclaringType);
+ }
+
  JsonParameterInfoValues jsonInfo = new()
  {
- Name = reflectionInfo.Name!,
+ Name = reflectionInfo.Name,
  ParameterType = reflectionInfo.ParameterType,
  Position = reflectionInfo.Position,
  HasDefaultValue = reflectionInfo.HasDefaultValue,

src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs

@@ -709,6 +709,13 @@ public static void ThrowNotSupportedException_NoMetadataForType(Type type, IJson
  throw new NotSupportedException(SR.Format(SR.NoMetadataForType, type, resolver?.GetType().FullName ?? "<null>"));
  }
 
+
+ [DoesNotReturn]
+ public static void ThrowNotSupportedException_ConstructorContainsNullParameterNames(Type declaringType)
+ {
+ throw new NotSupportedException(SR.Format(SR.ConstructorContainsNullParameterNames, declaringType));
+ }
+
  [DoesNotReturn]
  public static void ThrowInvalidOperationException_NoMetadataForType(Type type, IJsonTypeInfoResolver? resolver)
  {

src/libraries/System.Text.Json/tests/Common/UnsupportedTypesTests.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
+using System.Reflection;
 using System.Runtime.Serialization;
 using System.Threading;
 using System.Threading.Tasks;
@@ -20,110 +21,117 @@ public UnsupportedTypesTests(
  SupportsJsonPathOnSerialize = supportsJsonPathOnSerialize;
  }
 
- [Fact]
- public async Task DeserializeUnsupportedType()
+ [Theory]
+ [MemberData(nameof(GetUnsupportedValues))]
+ public async Task DeserializeUnsupportedType<T>(ValueWrapper<T> wrapper)
  {
- // Any test payload is fine.
- string json = @"""Some string""";
+ _ = wrapper; // only used to instantiate T
 
- await RunTest<Type>(json);
- await RunTest<SerializationInfo>(json);
- await RunTest<IntPtr>(json);
- await RunTest<IntPtr?>(json); // One nullable variation.
- await RunTest<UIntPtr>(json);
+ string json = @"""Some string"""; // Any test payload is fine.
 
- async Task RunTest<T>(string json)
- {
- Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
- string fullName = type.FullName;
+ Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
+ string fullName = type.FullName;
 
-NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<T>(json));
-string exAsStr = ex.ToString();
-Assert.Contains(fullName, exAsStr);
-Assert.Contains("$", exAsStr);
+ NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<T>(json));
+ string exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$", exAsStr);
 
-json = $@"{{""Prop"":{json}}}";
+ json = $@"{{""Prop"":{json}}}";
 
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<ClassWithType<T>>(json));
-exAsStr = ex.ToString();
-Assert.Contains(fullName, exAsStr);
-Assert.Contains("$.Prop", exAsStr);
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<ClassWithType<T>>(json));
+ exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$.Prop", exAsStr);
 
-// Verify Nullable<> semantics. NSE is not thrown because the serializer handles null.
-if (isNullableOfT)
-{
-Assert.Null(JsonSerializer.Deserialize<T>("null"));
+ // Verify Nullable<> semantics. NSE is not thrown because the serializer handles null.
+ if (isNullableOfT)
+ {
+ Assert.Null(JsonSerializer.Deserialize<T>("null"));
 
- json = $@"{{""Prop"":null}}";
- ClassWithType<T> obj = await Serializer.DeserializeWrapper<ClassWithType<T>>(json);
- Assert.Null(obj.Prop);
- }
+ json = $@"{{""Prop"":null}}";
+ ClassWithType<T> obj = await Serializer.DeserializeWrapper<ClassWithType<T>>(json);
+ Assert.Null(obj.Prop);
  }
  }
 
- [Fact]
- public async Task SerializeUnsupportedType()
+ [Theory]
+ [MemberData(nameof(GetUnsupportedValues))]
+ public async Task SerializeUnsupportedType<T>(ValueWrapper<T> wrapper)
  {
- // TODO refactor to Xunit theory
- await RunTest(typeof(int));
- await RunTest(new SerializationInfo(typeof(Type), new FormatterConverter()));
- await RunTest((IntPtr)123);
- await RunTest<IntPtr?>(new IntPtr(123)); // One nullable variation.
- await RunTest((UIntPtr)123);
-
- async Task RunTest<T>(T value)
+ T value = wrapper.value;
+
+ Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
+ string fullName = type.FullName;
+
+ NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(value));
+ string exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$", exAsStr);
+
+ ClassWithType<T> obj = new ClassWithType<T> { Prop = value };
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(obj));
+ exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+
+ if (SupportsJsonPathOnSerialize)
+ {
+ Assert.Contains("$.Prop", exAsStr);
+ }
+ else
  {
- Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
- string fullName = type.FullName;
-
- NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(value));
- string exAsStr = ex.ToString();
- Assert.Contains(fullName, exAsStr);
- Assert.Contains("$", exAsStr);
-
- ClassWithType<T> obj = new ClassWithType<T> { Prop = value };
- ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(obj));
- exAsStr = ex.ToString();
- Assert.Contains(fullName, exAsStr);
-
- if (SupportsJsonPathOnSerialize)
- {
- Assert.Contains("$.Prop", exAsStr);
- }
- else
- {
- Assert.Contains("$.", exAsStr);
- Assert.DoesNotContain("$.Prop", exAsStr);
- }
-
- // Verify null semantics. NSE is not thrown because the serializer handles null.
- if (!type.IsValueType || isNullableOfT)
- {
- string serialized = await Serializer.SerializeWrapper<T>((T)(object)null);
- Assert.Equal("null", serialized);
-
- obj.Prop = (T)(object)null;
- serialized = await Serializer.SerializeWrapper(obj);
- Assert.Equal(@"{""Prop"":null}", serialized);
-
- serialized = await Serializer.SerializeWrapper(obj, new JsonSerializerOptions { IgnoreNullValues = true });
- Assert.Equal(@"{}", serialized);
- }
+ Assert.Contains("$.", exAsStr);
+ Assert.DoesNotContain("$.Prop", exAsStr);
+ }
+
+ // Verify null semantics. NSE is not thrown because the serializer handles null.
+ if (!type.IsValueType || isNullableOfT)
+ {
+ string serialized = await Serializer.SerializeWrapper<T>((T)(object)null);
+ Assert.Equal("null", serialized);
+
+ obj.Prop = (T)(object)null;
+ serialized = await Serializer.SerializeWrapper(obj);
+ Assert.Equal(@"{""Prop"":null}", serialized);
+
+ serialized = await Serializer.SerializeWrapper(obj, new JsonSerializerOptions { IgnoreNullValues = true });
+ Assert.Equal(@"{}", serialized);
+ }
 
 #if !BUILDING_SOURCE_GENERATOR_TESTS
-Type runtimeType = GetNullableOfTUnderlyingType(value.GetType(), out bool _);
+ Type runtimeType = GetNullableOfTUnderlyingType(value.GetType(), out bool _);
 
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper<object>(value));
-exAsStr = ex.ToString();
-Assert.Contains(runtimeType.FullName, exAsStr);
-Assert.Contains("$", exAsStr);
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper<object>(value));
+ exAsStr = ex.ToString();
+ Assert.Contains(runtimeType.FullName, exAsStr);
+ Assert.Contains("$", exAsStr);
 
-ClassWithType<object> polyObj = new ClassWithType<object> { Prop = value };
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(polyObj));
-exAsStr = ex.ToString();
-Assert.Contains(runtimeType.FullName, exAsStr);
+ ClassWithType<object> polyObj = new ClassWithType<object> { Prop = value };
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(polyObj));
+ exAsStr = ex.ToString();
+ Assert.Contains(runtimeType.FullName, exAsStr);
 #endif
- }
+ }
+
+ public static IEnumerable<object[]> GetUnsupportedValues()
+ {
+ yield return WrapArgs(typeof(int));
+ yield return WrapArgs(typeof(ClassWithExtensionProperty).GetConstructor(Array.Empty<Type>()));
+ yield return WrapArgs(typeof(ClassWithExtensionProperty).GetProperty(nameof(ClassWithExtensionProperty.MyInt)));
+ yield return WrapArgs(new SerializationInfo(typeof(Type), new FormatterConverter()));
+ yield return WrapArgs((IntPtr)123);
+ yield return WrapArgs<IntPtr?>(new IntPtr(123)); // One nullable variation.
+ yield return WrapArgs((UIntPtr)123);
+
+ static object[] WrapArgs<T>(T value) => new object[] { new ValueWrapper<T>(value) };
+ }
+
+ // Helper record used to path both value & type information to generic theories.
+ // This is needed e.g. when passing System.Type instances whose runtime type
+ // actually is System.Reflection.RuntimeType.
+ public record ValueWrapper<T>(T value)
+ {
+ public override string ToString() => value.ToString();
  }
 
  public class ClassWithIntPtr
@@ -151,6 +159,21 @@ public override void Write(Utf8JsonWriter writer, IntPtr value, JsonSerializerOp
  }
  }
 
+#if !BUILDING_SOURCE_GENERATOR_TESTS
+ [Fact]
+ public async Task TypeWithNullConstructorParameterName_ThrowsNotSupportedException()
+ {
+ // Regression test for https://github.com/dotnet/runtime/issues/58690
+ Type type = Assembly.GetExecutingAssembly().GetType("System.Runtime.CompilerServices.NullableContextAttribute")!;
+ ConstructorInfo ctorInfo = type.GetConstructor(new Type[] { typeof(byte) });
+ Assert.True(string.IsNullOrEmpty(ctorInfo.GetParameters()[0].Name));
+ object value = ctorInfo.Invoke(new object[] { (byte)0 });
+
+ await Assert.ThrowsAnyAsync<NotSupportedException>(() => Serializer.SerializeWrapper(value));
+ await Assert.ThrowsAnyAsync<NotSupportedException>(() => Serializer.DeserializeWrapper("{}", type));
+ }
+#endif
+
  [Fact]
  public async Task RuntimeConverterIsSupported_IntPtr()
  {

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

@@ -101,7 +101,7 @@ private sealed class Parser
 
  // Unsupported types
  private readonly Type _delegateType;
- private readonly Type _typeType;
+ private readonly Type _memberInfoType;
  private readonly Type _serializationInfoType;
  private readonly Type _intPtrType;
  private readonly Type _uIntPtrType;
@@ -232,15 +232,15 @@ public Parser(Compilation compilation, in JsonSourceGenerationContext sourceGene
  _jsonObjectType = _metadataLoadContext.Resolve(JsonObjectFullName);
  _jsonValueType = _metadataLoadContext.Resolve(JsonValueFullName);
  _jsonDocumentType = _metadataLoadContext.Resolve(JsonDocumentFullName);
+ _dateOnlyType = _metadataLoadContext.Resolve(DateOnlyFullName);
+ _timeOnlyType = _metadataLoadContext.Resolve(TimeOnlyFullName);
 
  // Unsupported types.
  _delegateType = _metadataLoadContext.Resolve(SpecialType.System_Delegate);
-_typeType = _metadataLoadContext.Resolve(typeof(Type));
+_memberInfoType = _metadataLoadContext.Resolve(typeof(MemberInfo));
  _serializationInfoType = _metadataLoadContext.Resolve(typeof(Runtime.Serialization.SerializationInfo));
  _intPtrType = _metadataLoadContext.Resolve(typeof(IntPtr));
  _uIntPtrType = _metadataLoadContext.Resolve(typeof(UIntPtr));
- _dateOnlyType = _metadataLoadContext.Resolve(DateOnlyFullName);
- _timeOnlyType = _metadataLoadContext.Resolve(TimeOnlyFullName);
 
  _jsonConverterOfTType = _metadataLoadContext.Resolve(JsonConverterOfTFullName);
 
@@ -960,7 +960,10 @@ private TypeGenerationSpec GetOrAddTypeGenerationSpec(Type type, JsonSourceGener
  }
  }
  }
- else if (_knownUnsupportedTypes.Contains(type) || _delegateType.IsAssignableFrom(type))
+ else if (
+ _knownUnsupportedTypes.Contains(type) ||
+ _memberInfoType.IsAssignableFrom(type) ||
+ _delegateType.IsAssignableFrom(type))
  {
  classType = ClassType.KnownUnsupportedType;
  }
@@ -1590,7 +1593,6 @@ private void PopulateKnownTypes()
  AddTypeIfNotNull(_knownTypes, _jsonValueType);
  AddTypeIfNotNull(_knownTypes, _jsonDocumentType);
 
- _knownUnsupportedTypes.Add(_typeType);
  _knownUnsupportedTypes.Add(_serializationInfoType);
  _knownUnsupportedTypes.Add(_intPtrType);
  _knownUnsupportedTypes.Add(_uIntPtrType);

src/libraries/System.Text.Json/gen/Reflection/TypeWrapper.cs

@@ -595,17 +595,11 @@ protected override bool IsPrimitiveImpl()
 
  public override bool IsAssignableFrom(Type c)
  {
- if (c is TypeWrapper tr)
- {
- return tr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
- (tr._namedTypeSymbol != null && tr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default));
- }
- else if (_metadataLoadContext.Resolve(c) is TypeWrapper trr)
- {
- return trr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
- (trr._namedTypeSymbol != null && trr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default));
- }
- return false;
+ TypeWrapper? tr = c as TypeWrapper ?? _metadataLoadContext.Resolve(c) as TypeWrapper;
+
+ return tr is not null &&
+ (tr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
+ (tr._namedTypeSymbol != null && tr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default)));
  }
 
 #pragma warning disable RS1024 // Compare symbols correctly

src/libraries/System.Text.Json/src/Resources/Strings.resx

@@ -518,6 +518,9 @@
  <data name="CannotPopulateCollection" xml:space="preserve">
  <value>The collection type '{0}' is abstract, an interface, or is read only, and could not be instantiated and populated.</value>
  </data>
+ <data name="ConstructorContainsNullParameterNames" xml:space="preserve">
+ <value>The deserialization constructor for type '{0}' contains parameters with null names. This might happen because the parameter names have been trimmed by the linker. Consider using the source generated serializer instead.</value>
+ </data>
  <data name="DefaultIgnoreConditionAlreadySpecified" xml:space="preserve">
  <value>'IgnoreNullValues' and 'DefaultIgnoreCondition' cannot both be set to non-default values.</value>
  </data>

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/UnsupportedTypeConverterFactory.cs

@@ -15,8 +15,8 @@ public override bool CanConvert(Type type)
  // If a type is added, also add to the SourceGeneration project.
 
  return
- // There's no safe way to construct a Type from untrusted user input.
- typeof(Type).IsAssignableFrom(type) ||
+ // There's no safe way to construct a Type/MemberInfo from untrusted user input.
+ typeof(MemberInfo).IsAssignableFrom(type) ||
  // (De)serialization of SerializationInfo is already disallowed due to Type being disallowed
  // (the two ctors on SerializationInfo take a Type, and a Type member is present when serializing).
  // Explicitly disallowing this type provides a clear exception when ctors with

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

@@ -230,22 +230,25 @@ private static bool PropertyIsOverriddenAndIgnored(
 
  internal override JsonParameterInfoValues[] GetParameterInfoValues()
  {
- ParameterInfo[] parameters = Converter.ConstructorInfo!.GetParameters();
- return GetParameterInfoArray(parameters);
- }
-
- private static JsonParameterInfoValues[] GetParameterInfoArray(ParameterInfo[] parameters)
- {
+ Debug.Assert(Converter.ConstructorInfo != null);
+ ParameterInfo[] parameters = Converter.ConstructorInfo.GetParameters();
  int parameterCount = parameters.Length;
  JsonParameterInfoValues[] jsonParameters = new JsonParameterInfoValues[parameterCount];
 
  for (int i = 0; i < parameterCount; i++)
  {
  ParameterInfo reflectionInfo = parameters[i];
 
+ // Trimmed parameter names are reported as null in CoreCLR or "" in Mono.
+ if (string.IsNullOrEmpty(reflectionInfo.Name))
+ {
+ Debug.Assert(Converter.ConstructorInfo.DeclaringType != null);
+ ThrowHelper.ThrowNotSupportedException_BaseConverterDoesNotSupportMetadata(Converter.ConstructorInfo.DeclaringType);
+ }
+
  JsonParameterInfoValues jsonInfo = new()
  {
- Name = reflectionInfo.Name!,
+ Name = reflectionInfo.Name,
  ParameterType = reflectionInfo.ParameterType,
  Position = reflectionInfo.Position,
  HasDefaultValue = reflectionInfo.HasDefaultValue,

src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs

@@ -709,6 +709,13 @@ public static void ThrowNotSupportedException_NoMetadataForType(Type type, IJson
  throw new NotSupportedException(SR.Format(SR.NoMetadataForType, type, resolver?.GetType().FullName ?? "<null>"));
  }
 
+
+ [DoesNotReturn]
+ public static void ThrowNotSupportedException_ConstructorContainsNullParameterNames(Type declaringType)
+ {
+ throw new NotSupportedException(SR.Format(SR.ConstructorContainsNullParameterNames, declaringType));
+ }
+
  [DoesNotReturn]
  public static void ThrowInvalidOperationException_NoMetadataForType(Type type, IJsonTypeInfoResolver? resolver)
  {

src/libraries/System.Text.Json/tests/Common/UnsupportedTypesTests.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
+using System.Reflection;
 using System.Runtime.Serialization;
 using System.Threading;
 using System.Threading.Tasks;
@@ -20,110 +21,117 @@ public UnsupportedTypesTests(
  SupportsJsonPathOnSerialize = supportsJsonPathOnSerialize;
  }
 
- [Fact]
- public async Task DeserializeUnsupportedType()
+ [Theory]
+ [MemberData(nameof(GetUnsupportedValues))]
+ public async Task DeserializeUnsupportedType<T>(ValueWrapper<T> wrapper)
  {
- // Any test payload is fine.
- string json = @"""Some string""";
+ _ = wrapper; // only used to instantiate T
 
- await RunTest<Type>(json);
- await RunTest<SerializationInfo>(json);
- await RunTest<IntPtr>(json);
- await RunTest<IntPtr?>(json); // One nullable variation.
- await RunTest<UIntPtr>(json);
+ string json = @"""Some string"""; // Any test payload is fine.
 
- async Task RunTest<T>(string json)
- {
- Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
- string fullName = type.FullName;
+ Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
+ string fullName = type.FullName;
 
-NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<T>(json));
-string exAsStr = ex.ToString();
-Assert.Contains(fullName, exAsStr);
-Assert.Contains("$", exAsStr);
+ NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<T>(json));
+ string exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$", exAsStr);
 
-json = $@"{{""Prop"":{json}}}";
+ json = $@"{{""Prop"":{json}}}";
 
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<ClassWithType<T>>(json));
-exAsStr = ex.ToString();
-Assert.Contains(fullName, exAsStr);
-Assert.Contains("$.Prop", exAsStr);
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<ClassWithType<T>>(json));
+ exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$.Prop", exAsStr);
 
-// Verify Nullable<> semantics. NSE is not thrown because the serializer handles null.
-if (isNullableOfT)
-{
-Assert.Null(JsonSerializer.Deserialize<T>("null"));
+ // Verify Nullable<> semantics. NSE is not thrown because the serializer handles null.
+ if (isNullableOfT)
+ {
+ Assert.Null(JsonSerializer.Deserialize<T>("null"));
 
- json = $@"{{""Prop"":null}}";
- ClassWithType<T> obj = await Serializer.DeserializeWrapper<ClassWithType<T>>(json);
- Assert.Null(obj.Prop);
- }
+ json = $@"{{""Prop"":null}}";
+ ClassWithType<T> obj = await Serializer.DeserializeWrapper<ClassWithType<T>>(json);
+ Assert.Null(obj.Prop);
  }
  }
 
- [Fact]
- public async Task SerializeUnsupportedType()
+ [Theory]
+ [MemberData(nameof(GetUnsupportedValues))]
+ public async Task SerializeUnsupportedType<T>(ValueWrapper<T> wrapper)
  {
- // TODO refactor to Xunit theory
- await RunTest(typeof(int));
- await RunTest(new SerializationInfo(typeof(Type), new FormatterConverter()));
- await RunTest((IntPtr)123);
- await RunTest<IntPtr?>(new IntPtr(123)); // One nullable variation.
- await RunTest((UIntPtr)123);
-
- async Task RunTest<T>(T value)
+ T value = wrapper.value;
+
+ Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
+ string fullName = type.FullName;
+
+ NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(value));
+ string exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$", exAsStr);
+
+ ClassWithType<T> obj = new ClassWithType<T> { Prop = value };
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(obj));
+ exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+
+ if (SupportsJsonPathOnSerialize)
+ {
+ Assert.Contains("$.Prop", exAsStr);
+ }
+ else
  {
- Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
- string fullName = type.FullName;
-
- NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(value));
- string exAsStr = ex.ToString();
- Assert.Contains(fullName, exAsStr);
- Assert.Contains("$", exAsStr);
-
- ClassWithType<T> obj = new ClassWithType<T> { Prop = value };
- ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(obj));
- exAsStr = ex.ToString();
- Assert.Contains(fullName, exAsStr);
-
- if (SupportsJsonPathOnSerialize)
- {
- Assert.Contains("$.Prop", exAsStr);
- }
- else
- {
- Assert.Contains("$.", exAsStr);
- Assert.DoesNotContain("$.Prop", exAsStr);
- }
-
- // Verify null semantics. NSE is not thrown because the serializer handles null.
- if (!type.IsValueType || isNullableOfT)
- {
- string serialized = await Serializer.SerializeWrapper<T>((T)(object)null);
- Assert.Equal("null", serialized);
-
- obj.Prop = (T)(object)null;
- serialized = await Serializer.SerializeWrapper(obj);
- Assert.Equal(@"{""Prop"":null}", serialized);
-
- serialized = await Serializer.SerializeWrapper(obj, new JsonSerializerOptions { IgnoreNullValues = true });
- Assert.Equal(@"{}", serialized);
- }
+ Assert.Contains("$.", exAsStr);
+ Assert.DoesNotContain("$.Prop", exAsStr);
+ }
+
+ // Verify null semantics. NSE is not thrown because the serializer handles null.
+ if (!type.IsValueType || isNullableOfT)
+ {
+ string serialized = await Serializer.SerializeWrapper<T>((T)(object)null);
+ Assert.Equal("null", serialized);
+
+ obj.Prop = (T)(object)null;
+ serialized = await Serializer.SerializeWrapper(obj);
+ Assert.Equal(@"{""Prop"":null}", serialized);
+
+ serialized = await Serializer.SerializeWrapper(obj, new JsonSerializerOptions { IgnoreNullValues = true });
+ Assert.Equal(@"{}", serialized);
+ }
 
 #if !BUILDING_SOURCE_GENERATOR_TESTS
-Type runtimeType = GetNullableOfTUnderlyingType(value.GetType(), out bool _);
+ Type runtimeType = GetNullableOfTUnderlyingType(value.GetType(), out bool _);
 
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper<object>(value));
-exAsStr = ex.ToString();
-Assert.Contains(runtimeType.FullName, exAsStr);
-Assert.Contains("$", exAsStr);
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper<object>(value));
+ exAsStr = ex.ToString();
+ Assert.Contains(runtimeType.FullName, exAsStr);
+ Assert.Contains("$", exAsStr);
 
-ClassWithType<object> polyObj = new ClassWithType<object> { Prop = value };
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(polyObj));
-exAsStr = ex.ToString();
-Assert.Contains(runtimeType.FullName, exAsStr);
+ ClassWithType<object> polyObj = new ClassWithType<object> { Prop = value };
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(polyObj));
+ exAsStr = ex.ToString();
+ Assert.Contains(runtimeType.FullName, exAsStr);
 #endif
- }
+ }
+
+ public static IEnumerable<object[]> GetUnsupportedValues()
+ {
+ yield return WrapArgs(typeof(int));
+ yield return WrapArgs(typeof(ClassWithExtensionProperty).GetConstructor(Array.Empty<Type>()));
+ yield return WrapArgs(typeof(ClassWithExtensionProperty).GetProperty(nameof(ClassWithExtensionProperty.MyInt)));
+ yield return WrapArgs(new SerializationInfo(typeof(Type), new FormatterConverter()));
+ yield return WrapArgs((IntPtr)123);
+ yield return WrapArgs<IntPtr?>(new IntPtr(123)); // One nullable variation.
+ yield return WrapArgs((UIntPtr)123);
+
+ static object[] WrapArgs<T>(T value) => new object[] { new ValueWrapper<T>(value) };
+ }
+
+ // Helper record used to path both value & type information to generic theories.
+ // This is needed e.g. when passing System.Type instances whose runtime type
+ // actually is System.Reflection.RuntimeType.
+ public record ValueWrapper<T>(T value)
+ {
+ public override string ToString() => value.ToString();
  }
 
  public class ClassWithIntPtr
@@ -151,6 +159,21 @@ public override void Write(Utf8JsonWriter writer, IntPtr value, JsonSerializerOp
  }
  }
 
+#if !BUILDING_SOURCE_GENERATOR_TESTS
+ [Fact]
+ public async Task TypeWithNullConstructorParameterName_ThrowsNotSupportedException()
+ {
+ // Regression test for https://github.com/dotnet/runtime/issues/58690
+ Type type = Assembly.GetExecutingAssembly().GetType("System.Runtime.CompilerServices.NullableContextAttribute")!;
+ ConstructorInfo ctorInfo = type.GetConstructor(new Type[] { typeof(byte) });
+ Assert.True(string.IsNullOrEmpty(ctorInfo.GetParameters()[0].Name));
+ object value = ctorInfo.Invoke(new object[] { (byte)0 });
+
+ await Assert.ThrowsAnyAsync<NotSupportedException>(() => Serializer.SerializeWrapper(value));
+ await Assert.ThrowsAnyAsync<NotSupportedException>(() => Serializer.DeserializeWrapper("{}", type));
+ }
+#endif
+
  [Fact]
  public async Task RuntimeConverterIsSupported_IntPtr()
  {

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

@@ -101,7 +101,7 @@ private sealed class Parser
 
  // Unsupported types
  private readonly Type _delegateType;
- private readonly Type _typeType;
+ private readonly Type _memberInfoType;
  private readonly Type _serializationInfoType;
  private readonly Type _intPtrType;
  private readonly Type _uIntPtrType;
@@ -232,15 +232,15 @@ public Parser(Compilation compilation, in JsonSourceGenerationContext sourceGene
  _jsonObjectType = _metadataLoadContext.Resolve(JsonObjectFullName);
  _jsonValueType = _metadataLoadContext.Resolve(JsonValueFullName);
  _jsonDocumentType = _metadataLoadContext.Resolve(JsonDocumentFullName);
+ _dateOnlyType = _metadataLoadContext.Resolve(DateOnlyFullName);
+ _timeOnlyType = _metadataLoadContext.Resolve(TimeOnlyFullName);
 
  // Unsupported types.
  _delegateType = _metadataLoadContext.Resolve(SpecialType.System_Delegate);
-_typeType = _metadataLoadContext.Resolve(typeof(Type));
+_memberInfoType = _metadataLoadContext.Resolve(typeof(MemberInfo));
  _serializationInfoType = _metadataLoadContext.Resolve(typeof(Runtime.Serialization.SerializationInfo));
  _intPtrType = _metadataLoadContext.Resolve(typeof(IntPtr));
  _uIntPtrType = _metadataLoadContext.Resolve(typeof(UIntPtr));
- _dateOnlyType = _metadataLoadContext.Resolve(DateOnlyFullName);
- _timeOnlyType = _metadataLoadContext.Resolve(TimeOnlyFullName);
 
  _jsonConverterOfTType = _metadataLoadContext.Resolve(JsonConverterOfTFullName);
 
@@ -960,7 +960,10 @@ private TypeGenerationSpec GetOrAddTypeGenerationSpec(Type type, JsonSourceGener
  }
  }
  }
- else if (_knownUnsupportedTypes.Contains(type) || _delegateType.IsAssignableFrom(type))
+ else if (
+ _knownUnsupportedTypes.Contains(type) ||
+ _memberInfoType.IsAssignableFrom(type) ||
+ _delegateType.IsAssignableFrom(type))
  {
  classType = ClassType.KnownUnsupportedType;
  }
@@ -1590,7 +1593,6 @@ private void PopulateKnownTypes()
  AddTypeIfNotNull(_knownTypes, _jsonValueType);
  AddTypeIfNotNull(_knownTypes, _jsonDocumentType);
 
- _knownUnsupportedTypes.Add(_typeType);
  _knownUnsupportedTypes.Add(_serializationInfoType);
  _knownUnsupportedTypes.Add(_intPtrType);
  _knownUnsupportedTypes.Add(_uIntPtrType);

src/libraries/System.Text.Json/gen/Reflection/TypeWrapper.cs

@@ -595,17 +595,11 @@ protected override bool IsPrimitiveImpl()
 
  public override bool IsAssignableFrom(Type c)
  {
- if (c is TypeWrapper tr)
- {
- return tr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
- (tr._namedTypeSymbol != null && tr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default));
- }
- else if (_metadataLoadContext.Resolve(c) is TypeWrapper trr)
- {
- return trr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
- (trr._namedTypeSymbol != null && trr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default));
- }
- return false;
+ TypeWrapper? tr = c as TypeWrapper ?? _metadataLoadContext.Resolve(c) as TypeWrapper;
+
+ return tr is not null &&
+ (tr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
+ (tr._namedTypeSymbol != null && tr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default)));
  }
 
 #pragma warning disable RS1024 // Compare symbols correctly

src/libraries/System.Text.Json/src/Resources/Strings.resx

@@ -518,6 +518,9 @@
  <data name="CannotPopulateCollection" xml:space="preserve">
  <value>The collection type '{0}' is abstract, an interface, or is read only, and could not be instantiated and populated.</value>
  </data>
+ <data name="ConstructorContainsNullParameterNames" xml:space="preserve">
+ <value>The deserialization constructor for type '{0}' contains parameters with null names. This might happen because the parameter names have been trimmed by the linker. Consider using the source generated serializer instead.</value>
+ </data>
  <data name="DefaultIgnoreConditionAlreadySpecified" xml:space="preserve">
  <value>'IgnoreNullValues' and 'DefaultIgnoreCondition' cannot both be set to non-default values.</value>
  </data>

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/UnsupportedTypeConverterFactory.cs

@@ -15,8 +15,8 @@ public override bool CanConvert(Type type)
  // If a type is added, also add to the SourceGeneration project.
 
  return
- // There's no safe way to construct a Type from untrusted user input.
- typeof(Type).IsAssignableFrom(type) ||
+ // There's no safe way to construct a Type/MemberInfo from untrusted user input.
+ typeof(MemberInfo).IsAssignableFrom(type) ||
  // (De)serialization of SerializationInfo is already disallowed due to Type being disallowed
  // (the two ctors on SerializationInfo take a Type, and a Type member is present when serializing).
  // Explicitly disallowing this type provides a clear exception when ctors with

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

@@ -230,22 +230,25 @@ private static bool PropertyIsOverriddenAndIgnored(
 
  internal override JsonParameterInfoValues[] GetParameterInfoValues()
  {
- ParameterInfo[] parameters = Converter.ConstructorInfo!.GetParameters();
- return GetParameterInfoArray(parameters);
- }
-
- private static JsonParameterInfoValues[] GetParameterInfoArray(ParameterInfo[] parameters)
- {
+ Debug.Assert(Converter.ConstructorInfo != null);
+ ParameterInfo[] parameters = Converter.ConstructorInfo.GetParameters();
  int parameterCount = parameters.Length;
  JsonParameterInfoValues[] jsonParameters = new JsonParameterInfoValues[parameterCount];
 
  for (int i = 0; i < parameterCount; i++)
  {
  ParameterInfo reflectionInfo = parameters[i];
 
+ // Trimmed parameter names are reported as null in CoreCLR or "" in Mono.
+ if (string.IsNullOrEmpty(reflectionInfo.Name))
+ {
+ Debug.Assert(Converter.ConstructorInfo.DeclaringType != null);
+ ThrowHelper.ThrowNotSupportedException_BaseConverterDoesNotSupportMetadata(Converter.ConstructorInfo.DeclaringType);
+ }
+
  JsonParameterInfoValues jsonInfo = new()
  {
- Name = reflectionInfo.Name!,
+ Name = reflectionInfo.Name,
  ParameterType = reflectionInfo.ParameterType,
  Position = reflectionInfo.Position,
  HasDefaultValue = reflectionInfo.HasDefaultValue,

src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs

@@ -709,6 +709,13 @@ public static void ThrowNotSupportedException_NoMetadataForType(Type type, IJson
  throw new NotSupportedException(SR.Format(SR.NoMetadataForType, type, resolver?.GetType().FullName ?? "<null>"));
  }
 
+
+ [DoesNotReturn]
+ public static void ThrowNotSupportedException_ConstructorContainsNullParameterNames(Type declaringType)
+ {
+ throw new NotSupportedException(SR.Format(SR.ConstructorContainsNullParameterNames, declaringType));
+ }
+
  [DoesNotReturn]
  public static void ThrowInvalidOperationException_NoMetadataForType(Type type, IJsonTypeInfoResolver? resolver)
  {

src/libraries/System.Text.Json/tests/Common/UnsupportedTypesTests.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
+using System.Reflection;
 using System.Runtime.Serialization;
 using System.Threading;
 using System.Threading.Tasks;
@@ -20,110 +21,117 @@ public UnsupportedTypesTests(
  SupportsJsonPathOnSerialize = supportsJsonPathOnSerialize;
  }
 
- [Fact]
- public async Task DeserializeUnsupportedType()
+ [Theory]
+ [MemberData(nameof(GetUnsupportedValues))]
+ public async Task DeserializeUnsupportedType<T>(ValueWrapper<T> wrapper)
  {
- // Any test payload is fine.
- string json = @"""Some string""";
+ _ = wrapper; // only used to instantiate T
 
- await RunTest<Type>(json);
- await RunTest<SerializationInfo>(json);
- await RunTest<IntPtr>(json);
- await RunTest<IntPtr?>(json); // One nullable variation.
- await RunTest<UIntPtr>(json);
+ string json = @"""Some string"""; // Any test payload is fine.
 
- async Task RunTest<T>(string json)
- {
- Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
- string fullName = type.FullName;
+ Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
+ string fullName = type.FullName;
 
-NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<T>(json));
-string exAsStr = ex.ToString();
-Assert.Contains(fullName, exAsStr);
-Assert.Contains("$", exAsStr);
+ NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<T>(json));
+ string exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$", exAsStr);
 
-json = $@"{{""Prop"":{json}}}";
+ json = $@"{{""Prop"":{json}}}";
 
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<ClassWithType<T>>(json));
-exAsStr = ex.ToString();
-Assert.Contains(fullName, exAsStr);
-Assert.Contains("$.Prop", exAsStr);
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<ClassWithType<T>>(json));
+ exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$.Prop", exAsStr);
 
-// Verify Nullable<> semantics. NSE is not thrown because the serializer handles null.
-if (isNullableOfT)
-{
-Assert.Null(JsonSerializer.Deserialize<T>("null"));
+ // Verify Nullable<> semantics. NSE is not thrown because the serializer handles null.
+ if (isNullableOfT)
+ {
+ Assert.Null(JsonSerializer.Deserialize<T>("null"));
 
- json = $@"{{""Prop"":null}}";
- ClassWithType<T> obj = await Serializer.DeserializeWrapper<ClassWithType<T>>(json);
- Assert.Null(obj.Prop);
- }
+ json = $@"{{""Prop"":null}}";
+ ClassWithType<T> obj = await Serializer.DeserializeWrapper<ClassWithType<T>>(json);
+ Assert.Null(obj.Prop);
  }
  }
 
- [Fact]
- public async Task SerializeUnsupportedType()
+ [Theory]
+ [MemberData(nameof(GetUnsupportedValues))]
+ public async Task SerializeUnsupportedType<T>(ValueWrapper<T> wrapper)
  {
- // TODO refactor to Xunit theory
- await RunTest(typeof(int));
- await RunTest(new SerializationInfo(typeof(Type), new FormatterConverter()));
- await RunTest((IntPtr)123);
- await RunTest<IntPtr?>(new IntPtr(123)); // One nullable variation.
- await RunTest((UIntPtr)123);
-
- async Task RunTest<T>(T value)
+ T value = wrapper.value;
+
+ Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
+ string fullName = type.FullName;
+
+ NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(value));
+ string exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$", exAsStr);
+
+ ClassWithType<T> obj = new ClassWithType<T> { Prop = value };
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(obj));
+ exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+
+ if (SupportsJsonPathOnSerialize)
+ {
+ Assert.Contains("$.Prop", exAsStr);
+ }
+ else
  {
- Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
- string fullName = type.FullName;
-
- NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(value));
- string exAsStr = ex.ToString();
- Assert.Contains(fullName, exAsStr);
- Assert.Contains("$", exAsStr);
-
- ClassWithType<T> obj = new ClassWithType<T> { Prop = value };
- ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(obj));
- exAsStr = ex.ToString();
- Assert.Contains(fullName, exAsStr);
-
- if (SupportsJsonPathOnSerialize)
- {
- Assert.Contains("$.Prop", exAsStr);
- }
- else
- {
- Assert.Contains("$.", exAsStr);
- Assert.DoesNotContain("$.Prop", exAsStr);
- }
-
- // Verify null semantics. NSE is not thrown because the serializer handles null.
- if (!type.IsValueType || isNullableOfT)
- {
- string serialized = await Serializer.SerializeWrapper<T>((T)(object)null);
- Assert.Equal("null", serialized);
-
- obj.Prop = (T)(object)null;
- serialized = await Serializer.SerializeWrapper(obj);
- Assert.Equal(@"{""Prop"":null}", serialized);
-
- serialized = await Serializer.SerializeWrapper(obj, new JsonSerializerOptions { IgnoreNullValues = true });
- Assert.Equal(@"{}", serialized);
- }
+ Assert.Contains("$.", exAsStr);
+ Assert.DoesNotContain("$.Prop", exAsStr);
+ }
+
+ // Verify null semantics. NSE is not thrown because the serializer handles null.
+ if (!type.IsValueType || isNullableOfT)
+ {
+ string serialized = await Serializer.SerializeWrapper<T>((T)(object)null);
+ Assert.Equal("null", serialized);
+
+ obj.Prop = (T)(object)null;
+ serialized = await Serializer.SerializeWrapper(obj);
+ Assert.Equal(@"{""Prop"":null}", serialized);
+
+ serialized = await Serializer.SerializeWrapper(obj, new JsonSerializerOptions { IgnoreNullValues = true });
+ Assert.Equal(@"{}", serialized);
+ }
 
 #if !BUILDING_SOURCE_GENERATOR_TESTS
-Type runtimeType = GetNullableOfTUnderlyingType(value.GetType(), out bool _);
+ Type runtimeType = GetNullableOfTUnderlyingType(value.GetType(), out bool _);
 
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper<object>(value));
-exAsStr = ex.ToString();
-Assert.Contains(runtimeType.FullName, exAsStr);
-Assert.Contains("$", exAsStr);
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper<object>(value));
+ exAsStr = ex.ToString();
+ Assert.Contains(runtimeType.FullName, exAsStr);
+ Assert.Contains("$", exAsStr);
 
-ClassWithType<object> polyObj = new ClassWithType<object> { Prop = value };
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(polyObj));
-exAsStr = ex.ToString();
-Assert.Contains(runtimeType.FullName, exAsStr);
+ ClassWithType<object> polyObj = new ClassWithType<object> { Prop = value };
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(polyObj));
+ exAsStr = ex.ToString();
+ Assert.Contains(runtimeType.FullName, exAsStr);
 #endif
- }
+ }
+
+ public static IEnumerable<object[]> GetUnsupportedValues()
+ {
+ yield return WrapArgs(typeof(int));
+ yield return WrapArgs(typeof(ClassWithExtensionProperty).GetConstructor(Array.Empty<Type>()));
+ yield return WrapArgs(typeof(ClassWithExtensionProperty).GetProperty(nameof(ClassWithExtensionProperty.MyInt)));
+ yield return WrapArgs(new SerializationInfo(typeof(Type), new FormatterConverter()));
+ yield return WrapArgs((IntPtr)123);
+ yield return WrapArgs<IntPtr?>(new IntPtr(123)); // One nullable variation.
+ yield return WrapArgs((UIntPtr)123);
+
+ static object[] WrapArgs<T>(T value) => new object[] { new ValueWrapper<T>(value) };
+ }
+
+ // Helper record used to path both value & type information to generic theories.
+ // This is needed e.g. when passing System.Type instances whose runtime type
+ // actually is System.Reflection.RuntimeType.
+ public record ValueWrapper<T>(T value)
+ {
+ public override string ToString() => value.ToString();
  }
 
  public class ClassWithIntPtr
@@ -151,6 +159,21 @@ public override void Write(Utf8JsonWriter writer, IntPtr value, JsonSerializerOp
  }
  }
 
+#if !BUILDING_SOURCE_GENERATOR_TESTS
+ [Fact]
+ public async Task TypeWithNullConstructorParameterName_ThrowsNotSupportedException()
+ {
+ // Regression test for https://github.com/dotnet/runtime/issues/58690
+ Type type = Assembly.GetExecutingAssembly().GetType("System.Runtime.CompilerServices.NullableContextAttribute")!;
+ ConstructorInfo ctorInfo = type.GetConstructor(new Type[] { typeof(byte) });
+ Assert.True(string.IsNullOrEmpty(ctorInfo.GetParameters()[0].Name));
+ object value = ctorInfo.Invoke(new object[] { (byte)0 });
+
+ await Assert.ThrowsAnyAsync<NotSupportedException>(() => Serializer.SerializeWrapper(value));
+ await Assert.ThrowsAnyAsync<NotSupportedException>(() => Serializer.DeserializeWrapper("{}", type));
+ }
+#endif
+
  [Fact]
  public async Task RuntimeConverterIsSupported_IntPtr()
  {

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

@@ -101,7 +101,7 @@ private sealed class Parser
 
  // Unsupported types
  private readonly Type _delegateType;
- private readonly Type _typeType;
+ private readonly Type _memberInfoType;
  private readonly Type _serializationInfoType;
  private readonly Type _intPtrType;
  private readonly Type _uIntPtrType;
@@ -232,15 +232,15 @@ public Parser(Compilation compilation, in JsonSourceGenerationContext sourceGene
  _jsonObjectType = _metadataLoadContext.Resolve(JsonObjectFullName);
  _jsonValueType = _metadataLoadContext.Resolve(JsonValueFullName);
  _jsonDocumentType = _metadataLoadContext.Resolve(JsonDocumentFullName);
+ _dateOnlyType = _metadataLoadContext.Resolve(DateOnlyFullName);
+ _timeOnlyType = _metadataLoadContext.Resolve(TimeOnlyFullName);
 
  // Unsupported types.
  _delegateType = _metadataLoadContext.Resolve(SpecialType.System_Delegate);
-_typeType = _metadataLoadContext.Resolve(typeof(Type));
+_memberInfoType = _metadataLoadContext.Resolve(typeof(MemberInfo));
  _serializationInfoType = _metadataLoadContext.Resolve(typeof(Runtime.Serialization.SerializationInfo));
  _intPtrType = _metadataLoadContext.Resolve(typeof(IntPtr));
  _uIntPtrType = _metadataLoadContext.Resolve(typeof(UIntPtr));
- _dateOnlyType = _metadataLoadContext.Resolve(DateOnlyFullName);
- _timeOnlyType = _metadataLoadContext.Resolve(TimeOnlyFullName);
 
  _jsonConverterOfTType = _metadataLoadContext.Resolve(JsonConverterOfTFullName);
 
@@ -960,7 +960,10 @@ private TypeGenerationSpec GetOrAddTypeGenerationSpec(Type type, JsonSourceGener
  }
  }
  }
- else if (_knownUnsupportedTypes.Contains(type) || _delegateType.IsAssignableFrom(type))
+ else if (
+ _knownUnsupportedTypes.Contains(type) ||
+ _memberInfoType.IsAssignableFrom(type) ||
+ _delegateType.IsAssignableFrom(type))
  {
  classType = ClassType.KnownUnsupportedType;
  }
@@ -1590,7 +1593,6 @@ private void PopulateKnownTypes()
  AddTypeIfNotNull(_knownTypes, _jsonValueType);
  AddTypeIfNotNull(_knownTypes, _jsonDocumentType);
 
- _knownUnsupportedTypes.Add(_typeType);
  _knownUnsupportedTypes.Add(_serializationInfoType);
  _knownUnsupportedTypes.Add(_intPtrType);
  _knownUnsupportedTypes.Add(_uIntPtrType);

src/libraries/System.Text.Json/gen/Reflection/TypeWrapper.cs

@@ -595,17 +595,11 @@ protected override bool IsPrimitiveImpl()
 
  public override bool IsAssignableFrom(Type c)
  {
- if (c is TypeWrapper tr)
- {
- return tr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
- (tr._namedTypeSymbol != null && tr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default));
- }
- else if (_metadataLoadContext.Resolve(c) is TypeWrapper trr)
- {
- return trr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
- (trr._namedTypeSymbol != null && trr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default));
- }
- return false;
+ TypeWrapper? tr = c as TypeWrapper ?? _metadataLoadContext.Resolve(c) as TypeWrapper;
+
+ return tr is not null &&
+ (tr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
+ (tr._namedTypeSymbol != null && tr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default)));
  }
 
 #pragma warning disable RS1024 // Compare symbols correctly

src/libraries/System.Text.Json/src/Resources/Strings.resx

@@ -518,6 +518,9 @@
  <data name="CannotPopulateCollection" xml:space="preserve">
  <value>The collection type '{0}' is abstract, an interface, or is read only, and could not be instantiated and populated.</value>
  </data>
+ <data name="ConstructorContainsNullParameterNames" xml:space="preserve">
+ <value>The deserialization constructor for type '{0}' contains parameters with null names. This might happen because the parameter names have been trimmed by the linker. Consider using the source generated serializer instead.</value>
+ </data>
  <data name="DefaultIgnoreConditionAlreadySpecified" xml:space="preserve">
  <value>'IgnoreNullValues' and 'DefaultIgnoreCondition' cannot both be set to non-default values.</value>
  </data>

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/UnsupportedTypeConverterFactory.cs

@@ -15,8 +15,8 @@ public override bool CanConvert(Type type)
  // If a type is added, also add to the SourceGeneration project.
 
  return
- // There's no safe way to construct a Type from untrusted user input.
- typeof(Type).IsAssignableFrom(type) ||
+ // There's no safe way to construct a Type/MemberInfo from untrusted user input.
+ typeof(MemberInfo).IsAssignableFrom(type) ||
  // (De)serialization of SerializationInfo is already disallowed due to Type being disallowed
  // (the two ctors on SerializationInfo take a Type, and a Type member is present when serializing).
  // Explicitly disallowing this type provides a clear exception when ctors with

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

@@ -230,22 +230,25 @@ private static bool PropertyIsOverriddenAndIgnored(
 
  internal override JsonParameterInfoValues[] GetParameterInfoValues()
  {
- ParameterInfo[] parameters = Converter.ConstructorInfo!.GetParameters();
- return GetParameterInfoArray(parameters);
- }
-
- private static JsonParameterInfoValues[] GetParameterInfoArray(ParameterInfo[] parameters)
- {
+ Debug.Assert(Converter.ConstructorInfo != null);
+ ParameterInfo[] parameters = Converter.ConstructorInfo.GetParameters();
  int parameterCount = parameters.Length;
  JsonParameterInfoValues[] jsonParameters = new JsonParameterInfoValues[parameterCount];
 
  for (int i = 0; i < parameterCount; i++)
  {
  ParameterInfo reflectionInfo = parameters[i];
 
+ // Trimmed parameter names are reported as null in CoreCLR or "" in Mono.
+ if (string.IsNullOrEmpty(reflectionInfo.Name))
+ {
+ Debug.Assert(Converter.ConstructorInfo.DeclaringType != null);
+ ThrowHelper.ThrowNotSupportedException_BaseConverterDoesNotSupportMetadata(Converter.ConstructorInfo.DeclaringType);
+ }
+
  JsonParameterInfoValues jsonInfo = new()
  {
- Name = reflectionInfo.Name!,
+ Name = reflectionInfo.Name,
  ParameterType = reflectionInfo.ParameterType,
  Position = reflectionInfo.Position,
  HasDefaultValue = reflectionInfo.HasDefaultValue,

src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs

@@ -709,6 +709,13 @@ public static void ThrowNotSupportedException_NoMetadataForType(Type type, IJson
  throw new NotSupportedException(SR.Format(SR.NoMetadataForType, type, resolver?.GetType().FullName ?? "<null>"));
  }
 
+
+ [DoesNotReturn]
+ public static void ThrowNotSupportedException_ConstructorContainsNullParameterNames(Type declaringType)
+ {
+ throw new NotSupportedException(SR.Format(SR.ConstructorContainsNullParameterNames, declaringType));
+ }
+
  [DoesNotReturn]
  public static void ThrowInvalidOperationException_NoMetadataForType(Type type, IJsonTypeInfoResolver? resolver)
  {

src/libraries/System.Text.Json/tests/Common/UnsupportedTypesTests.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
+using System.Reflection;
 using System.Runtime.Serialization;
 using System.Threading;
 using System.Threading.Tasks;
@@ -20,110 +21,117 @@ public UnsupportedTypesTests(
  SupportsJsonPathOnSerialize = supportsJsonPathOnSerialize;
  }
 
- [Fact]
- public async Task DeserializeUnsupportedType()
+ [Theory]
+ [MemberData(nameof(GetUnsupportedValues))]
+ public async Task DeserializeUnsupportedType<T>(ValueWrapper<T> wrapper)
  {
- // Any test payload is fine.
- string json = @"""Some string""";
+ _ = wrapper; // only used to instantiate T
 
- await RunTest<Type>(json);
- await RunTest<SerializationInfo>(json);
- await RunTest<IntPtr>(json);
- await RunTest<IntPtr?>(json); // One nullable variation.
- await RunTest<UIntPtr>(json);
+ string json = @"""Some string"""; // Any test payload is fine.
 
- async Task RunTest<T>(string json)
- {
- Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
- string fullName = type.FullName;
+ Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
+ string fullName = type.FullName;
 
-NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<T>(json));
-string exAsStr = ex.ToString();
-Assert.Contains(fullName, exAsStr);
-Assert.Contains("$", exAsStr);
+ NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<T>(json));
+ string exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$", exAsStr);
 
-json = $@"{{""Prop"":{json}}}";
+ json = $@"{{""Prop"":{json}}}";
 
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<ClassWithType<T>>(json));
-exAsStr = ex.ToString();
-Assert.Contains(fullName, exAsStr);
-Assert.Contains("$.Prop", exAsStr);
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<ClassWithType<T>>(json));
+ exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$.Prop", exAsStr);
 
-// Verify Nullable<> semantics. NSE is not thrown because the serializer handles null.
-if (isNullableOfT)
-{
-Assert.Null(JsonSerializer.Deserialize<T>("null"));
+ // Verify Nullable<> semantics. NSE is not thrown because the serializer handles null.
+ if (isNullableOfT)
+ {
+ Assert.Null(JsonSerializer.Deserialize<T>("null"));
 
- json = $@"{{""Prop"":null}}";
- ClassWithType<T> obj = await Serializer.DeserializeWrapper<ClassWithType<T>>(json);
- Assert.Null(obj.Prop);
- }
+ json = $@"{{""Prop"":null}}";
+ ClassWithType<T> obj = await Serializer.DeserializeWrapper<ClassWithType<T>>(json);
+ Assert.Null(obj.Prop);
  }
  }
 
- [Fact]
- public async Task SerializeUnsupportedType()
+ [Theory]
+ [MemberData(nameof(GetUnsupportedValues))]
+ public async Task SerializeUnsupportedType<T>(ValueWrapper<T> wrapper)
  {
- // TODO refactor to Xunit theory
- await RunTest(typeof(int));
- await RunTest(new SerializationInfo(typeof(Type), new FormatterConverter()));
- await RunTest((IntPtr)123);
- await RunTest<IntPtr?>(new IntPtr(123)); // One nullable variation.
- await RunTest((UIntPtr)123);
-
- async Task RunTest<T>(T value)
+ T value = wrapper.value;
+
+ Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
+ string fullName = type.FullName;
+
+ NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(value));
+ string exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$", exAsStr);
+
+ ClassWithType<T> obj = new ClassWithType<T> { Prop = value };
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(obj));
+ exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+
+ if (SupportsJsonPathOnSerialize)
+ {
+ Assert.Contains("$.Prop", exAsStr);
+ }
+ else
  {
- Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
- string fullName = type.FullName;
-
- NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(value));
- string exAsStr = ex.ToString();
- Assert.Contains(fullName, exAsStr);
- Assert.Contains("$", exAsStr);
-
- ClassWithType<T> obj = new ClassWithType<T> { Prop = value };
- ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(obj));
- exAsStr = ex.ToString();
- Assert.Contains(fullName, exAsStr);
-
- if (SupportsJsonPathOnSerialize)
- {
- Assert.Contains("$.Prop", exAsStr);
- }
- else
- {
- Assert.Contains("$.", exAsStr);
- Assert.DoesNotContain("$.Prop", exAsStr);
- }
-
- // Verify null semantics. NSE is not thrown because the serializer handles null.
- if (!type.IsValueType || isNullableOfT)
- {
- string serialized = await Serializer.SerializeWrapper<T>((T)(object)null);
- Assert.Equal("null", serialized);
-
- obj.Prop = (T)(object)null;
- serialized = await Serializer.SerializeWrapper(obj);
- Assert.Equal(@"{""Prop"":null}", serialized);
-
- serialized = await Serializer.SerializeWrapper(obj, new JsonSerializerOptions { IgnoreNullValues = true });
- Assert.Equal(@"{}", serialized);
- }
+ Assert.Contains("$.", exAsStr);
+ Assert.DoesNotContain("$.Prop", exAsStr);
+ }
+
+ // Verify null semantics. NSE is not thrown because the serializer handles null.
+ if (!type.IsValueType || isNullableOfT)
+ {
+ string serialized = await Serializer.SerializeWrapper<T>((T)(object)null);
+ Assert.Equal("null", serialized);
+
+ obj.Prop = (T)(object)null;
+ serialized = await Serializer.SerializeWrapper(obj);
+ Assert.Equal(@"{""Prop"":null}", serialized);
+
+ serialized = await Serializer.SerializeWrapper(obj, new JsonSerializerOptions { IgnoreNullValues = true });
+ Assert.Equal(@"{}", serialized);
+ }
 
 #if !BUILDING_SOURCE_GENERATOR_TESTS
-Type runtimeType = GetNullableOfTUnderlyingType(value.GetType(), out bool _);
+ Type runtimeType = GetNullableOfTUnderlyingType(value.GetType(), out bool _);
 
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper<object>(value));
-exAsStr = ex.ToString();
-Assert.Contains(runtimeType.FullName, exAsStr);
-Assert.Contains("$", exAsStr);
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper<object>(value));
+ exAsStr = ex.ToString();
+ Assert.Contains(runtimeType.FullName, exAsStr);
+ Assert.Contains("$", exAsStr);
 
-ClassWithType<object> polyObj = new ClassWithType<object> { Prop = value };
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(polyObj));
-exAsStr = ex.ToString();
-Assert.Contains(runtimeType.FullName, exAsStr);
+ ClassWithType<object> polyObj = new ClassWithType<object> { Prop = value };
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(polyObj));
+ exAsStr = ex.ToString();
+ Assert.Contains(runtimeType.FullName, exAsStr);
 #endif
- }
+ }
+
+ public static IEnumerable<object[]> GetUnsupportedValues()
+ {
+ yield return WrapArgs(typeof(int));
+ yield return WrapArgs(typeof(ClassWithExtensionProperty).GetConstructor(Array.Empty<Type>()));
+ yield return WrapArgs(typeof(ClassWithExtensionProperty).GetProperty(nameof(ClassWithExtensionProperty.MyInt)));
+ yield return WrapArgs(new SerializationInfo(typeof(Type), new FormatterConverter()));
+ yield return WrapArgs((IntPtr)123);
+ yield return WrapArgs<IntPtr?>(new IntPtr(123)); // One nullable variation.
+ yield return WrapArgs((UIntPtr)123);
+
+ static object[] WrapArgs<T>(T value) => new object[] { new ValueWrapper<T>(value) };
+ }
+
+ // Helper record used to path both value & type information to generic theories.
+ // This is needed e.g. when passing System.Type instances whose runtime type
+ // actually is System.Reflection.RuntimeType.
+ public record ValueWrapper<T>(T value)
+ {
+ public override string ToString() => value.ToString();
  }
 
  public class ClassWithIntPtr
@@ -151,6 +159,21 @@ public override void Write(Utf8JsonWriter writer, IntPtr value, JsonSerializerOp
  }
  }
 
+#if !BUILDING_SOURCE_GENERATOR_TESTS
+ [Fact]
+ public async Task TypeWithNullConstructorParameterName_ThrowsNotSupportedException()
+ {
+ // Regression test for https://github.com/dotnet/runtime/issues/58690
+ Type type = Assembly.GetExecutingAssembly().GetType("System.Runtime.CompilerServices.NullableContextAttribute")!;
+ ConstructorInfo ctorInfo = type.GetConstructor(new Type[] { typeof(byte) });
+ Assert.True(string.IsNullOrEmpty(ctorInfo.GetParameters()[0].Name));
+ object value = ctorInfo.Invoke(new object[] { (byte)0 });
+
+ await Assert.ThrowsAnyAsync<NotSupportedException>(() => Serializer.SerializeWrapper(value));
+ await Assert.ThrowsAnyAsync<NotSupportedException>(() => Serializer.DeserializeWrapper("{}", type));
+ }
+#endif
+
  [Fact]
  public async Task RuntimeConverterIsSupported_IntPtr()
  {

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

@@ -101,7 +101,7 @@ private sealed class Parser
 
  // Unsupported types
  private readonly Type _delegateType;
- private readonly Type _typeType;
+ private readonly Type _memberInfoType;
  private readonly Type _serializationInfoType;
  private readonly Type _intPtrType;
  private readonly Type _uIntPtrType;
@@ -232,15 +232,15 @@ public Parser(Compilation compilation, in JsonSourceGenerationContext sourceGene
  _jsonObjectType = _metadataLoadContext.Resolve(JsonObjectFullName);
  _jsonValueType = _metadataLoadContext.Resolve(JsonValueFullName);
  _jsonDocumentType = _metadataLoadContext.Resolve(JsonDocumentFullName);
+ _dateOnlyType = _metadataLoadContext.Resolve(DateOnlyFullName);
+ _timeOnlyType = _metadataLoadContext.Resolve(TimeOnlyFullName);
 
  // Unsupported types.
  _delegateType = _metadataLoadContext.Resolve(SpecialType.System_Delegate);
-_typeType = _metadataLoadContext.Resolve(typeof(Type));
+_memberInfoType = _metadataLoadContext.Resolve(typeof(MemberInfo));
  _serializationInfoType = _metadataLoadContext.Resolve(typeof(Runtime.Serialization.SerializationInfo));
  _intPtrType = _metadataLoadContext.Resolve(typeof(IntPtr));
  _uIntPtrType = _metadataLoadContext.Resolve(typeof(UIntPtr));
- _dateOnlyType = _metadataLoadContext.Resolve(DateOnlyFullName);
- _timeOnlyType = _metadataLoadContext.Resolve(TimeOnlyFullName);
 
  _jsonConverterOfTType = _metadataLoadContext.Resolve(JsonConverterOfTFullName);
 
@@ -960,7 +960,10 @@ private TypeGenerationSpec GetOrAddTypeGenerationSpec(Type type, JsonSourceGener
  }
  }
  }
- else if (_knownUnsupportedTypes.Contains(type) || _delegateType.IsAssignableFrom(type))
+ else if (
+ _knownUnsupportedTypes.Contains(type) ||
+ _memberInfoType.IsAssignableFrom(type) ||
+ _delegateType.IsAssignableFrom(type))
  {
  classType = ClassType.KnownUnsupportedType;
  }
@@ -1590,7 +1593,6 @@ private void PopulateKnownTypes()
  AddTypeIfNotNull(_knownTypes, _jsonValueType);
  AddTypeIfNotNull(_knownTypes, _jsonDocumentType);
 
- _knownUnsupportedTypes.Add(_typeType);
  _knownUnsupportedTypes.Add(_serializationInfoType);
  _knownUnsupportedTypes.Add(_intPtrType);
  _knownUnsupportedTypes.Add(_uIntPtrType);

src/libraries/System.Text.Json/gen/Reflection/TypeWrapper.cs

@@ -595,17 +595,11 @@ protected override bool IsPrimitiveImpl()
 
  public override bool IsAssignableFrom(Type c)
  {
- if (c is TypeWrapper tr)
- {
- return tr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
- (tr._namedTypeSymbol != null && tr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default));
- }
- else if (_metadataLoadContext.Resolve(c) is TypeWrapper trr)
- {
- return trr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
- (trr._namedTypeSymbol != null && trr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default));
- }
- return false;
+ TypeWrapper? tr = c as TypeWrapper ?? _metadataLoadContext.Resolve(c) as TypeWrapper;
+
+ return tr is not null &&
+ (tr._typeSymbol.AllInterfaces.Contains(_typeSymbol, SymbolEqualityComparer.Default) ||
+ (tr._namedTypeSymbol != null && tr._namedTypeSymbol.BaseTypes().Contains(_typeSymbol, SymbolEqualityComparer.Default)));
  }
 
 #pragma warning disable RS1024 // Compare symbols correctly

src/libraries/System.Text.Json/src/Resources/Strings.resx

@@ -518,6 +518,9 @@
  <data name="CannotPopulateCollection" xml:space="preserve">
  <value>The collection type '{0}' is abstract, an interface, or is read only, and could not be instantiated and populated.</value>
  </data>
+ <data name="ConstructorContainsNullParameterNames" xml:space="preserve">
+ <value>The deserialization constructor for type '{0}' contains parameters with null names. This might happen because the parameter names have been trimmed by the linker. Consider using the source generated serializer instead.</value>
+ </data>
  <data name="DefaultIgnoreConditionAlreadySpecified" xml:space="preserve">
  <value>'IgnoreNullValues' and 'DefaultIgnoreCondition' cannot both be set to non-default values.</value>
  </data>

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/UnsupportedTypeConverterFactory.cs

@@ -15,8 +15,8 @@ public override bool CanConvert(Type type)
  // If a type is added, also add to the SourceGeneration project.
 
  return
- // There's no safe way to construct a Type from untrusted user input.
- typeof(Type).IsAssignableFrom(type) ||
+ // There's no safe way to construct a Type/MemberInfo from untrusted user input.
+ typeof(MemberInfo).IsAssignableFrom(type) ||
  // (De)serialization of SerializationInfo is already disallowed due to Type being disallowed
  // (the two ctors on SerializationInfo take a Type, and a Type member is present when serializing).
  // Explicitly disallowing this type provides a clear exception when ctors with

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

@@ -230,22 +230,25 @@ private static bool PropertyIsOverriddenAndIgnored(
 
  internal override JsonParameterInfoValues[] GetParameterInfoValues()
  {
- ParameterInfo[] parameters = Converter.ConstructorInfo!.GetParameters();
- return GetParameterInfoArray(parameters);
- }
-
- private static JsonParameterInfoValues[] GetParameterInfoArray(ParameterInfo[] parameters)
- {
+ Debug.Assert(Converter.ConstructorInfo != null);
+ ParameterInfo[] parameters = Converter.ConstructorInfo.GetParameters();
  int parameterCount = parameters.Length;
  JsonParameterInfoValues[] jsonParameters = new JsonParameterInfoValues[parameterCount];
 
  for (int i = 0; i < parameterCount; i++)
  {
  ParameterInfo reflectionInfo = parameters[i];
 
+ // Trimmed parameter names are reported as null in CoreCLR or "" in Mono.
+ if (string.IsNullOrEmpty(reflectionInfo.Name))
+ {
+ Debug.Assert(Converter.ConstructorInfo.DeclaringType != null);
+ ThrowHelper.ThrowNotSupportedException_BaseConverterDoesNotSupportMetadata(Converter.ConstructorInfo.DeclaringType);
+ }
+
  JsonParameterInfoValues jsonInfo = new()
  {
- Name = reflectionInfo.Name!,
+ Name = reflectionInfo.Name,
  ParameterType = reflectionInfo.ParameterType,
  Position = reflectionInfo.Position,
  HasDefaultValue = reflectionInfo.HasDefaultValue,

src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs

@@ -709,6 +709,13 @@ public static void ThrowNotSupportedException_NoMetadataForType(Type type, IJson
  throw new NotSupportedException(SR.Format(SR.NoMetadataForType, type, resolver?.GetType().FullName ?? "<null>"));
  }
 
+
+ [DoesNotReturn]
+ public static void ThrowNotSupportedException_ConstructorContainsNullParameterNames(Type declaringType)
+ {
+ throw new NotSupportedException(SR.Format(SR.ConstructorContainsNullParameterNames, declaringType));
+ }
+
  [DoesNotReturn]
  public static void ThrowInvalidOperationException_NoMetadataForType(Type type, IJsonTypeInfoResolver? resolver)
  {

src/libraries/System.Text.Json/tests/Common/UnsupportedTypesTests.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
+using System.Reflection;
 using System.Runtime.Serialization;
 using System.Threading;
 using System.Threading.Tasks;
@@ -20,110 +21,117 @@ public UnsupportedTypesTests(
  SupportsJsonPathOnSerialize = supportsJsonPathOnSerialize;
  }
 
- [Fact]
- public async Task DeserializeUnsupportedType()
+ [Theory]
+ [MemberData(nameof(GetUnsupportedValues))]
+ public async Task DeserializeUnsupportedType<T>(ValueWrapper<T> wrapper)
  {
- // Any test payload is fine.
- string json = @"""Some string""";
+ _ = wrapper; // only used to instantiate T
 
- await RunTest<Type>(json);
- await RunTest<SerializationInfo>(json);
- await RunTest<IntPtr>(json);
- await RunTest<IntPtr?>(json); // One nullable variation.
- await RunTest<UIntPtr>(json);
+ string json = @"""Some string"""; // Any test payload is fine.
 
- async Task RunTest<T>(string json)
- {
- Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
- string fullName = type.FullName;
+ Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
+ string fullName = type.FullName;
 
-NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<T>(json));
-string exAsStr = ex.ToString();
-Assert.Contains(fullName, exAsStr);
-Assert.Contains("$", exAsStr);
+ NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<T>(json));
+ string exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$", exAsStr);
 
-json = $@"{{""Prop"":{json}}}";
+ json = $@"{{""Prop"":{json}}}";
 
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<ClassWithType<T>>(json));
-exAsStr = ex.ToString();
-Assert.Contains(fullName, exAsStr);
-Assert.Contains("$.Prop", exAsStr);
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.DeserializeWrapper<ClassWithType<T>>(json));
+ exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$.Prop", exAsStr);
 
-// Verify Nullable<> semantics. NSE is not thrown because the serializer handles null.
-if (isNullableOfT)
-{
-Assert.Null(JsonSerializer.Deserialize<T>("null"));
+ // Verify Nullable<> semantics. NSE is not thrown because the serializer handles null.
+ if (isNullableOfT)
+ {
+ Assert.Null(JsonSerializer.Deserialize<T>("null"));
 
- json = $@"{{""Prop"":null}}";
- ClassWithType<T> obj = await Serializer.DeserializeWrapper<ClassWithType<T>>(json);
- Assert.Null(obj.Prop);
- }
+ json = $@"{{""Prop"":null}}";
+ ClassWithType<T> obj = await Serializer.DeserializeWrapper<ClassWithType<T>>(json);
+ Assert.Null(obj.Prop);
  }
  }
 
- [Fact]
- public async Task SerializeUnsupportedType()
+ [Theory]
+ [MemberData(nameof(GetUnsupportedValues))]
+ public async Task SerializeUnsupportedType<T>(ValueWrapper<T> wrapper)
  {
- // TODO refactor to Xunit theory
- await RunTest(typeof(int));
- await RunTest(new SerializationInfo(typeof(Type), new FormatterConverter()));
- await RunTest((IntPtr)123);
- await RunTest<IntPtr?>(new IntPtr(123)); // One nullable variation.
- await RunTest((UIntPtr)123);
-
- async Task RunTest<T>(T value)
+ T value = wrapper.value;
+
+ Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
+ string fullName = type.FullName;
+
+ NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(value));
+ string exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+ Assert.Contains("$", exAsStr);
+
+ ClassWithType<T> obj = new ClassWithType<T> { Prop = value };
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(obj));
+ exAsStr = ex.ToString();
+ Assert.Contains(fullName, exAsStr);
+
+ if (SupportsJsonPathOnSerialize)
+ {
+ Assert.Contains("$.Prop", exAsStr);
+ }
+ else
  {
- Type type = GetNullableOfTUnderlyingType(typeof(T), out bool isNullableOfT);
- string fullName = type.FullName;
-
- NotSupportedException ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(value));
- string exAsStr = ex.ToString();
- Assert.Contains(fullName, exAsStr);
- Assert.Contains("$", exAsStr);
-
- ClassWithType<T> obj = new ClassWithType<T> { Prop = value };
- ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(obj));
- exAsStr = ex.ToString();
- Assert.Contains(fullName, exAsStr);
-
- if (SupportsJsonPathOnSerialize)
- {
- Assert.Contains("$.Prop", exAsStr);
- }
- else
- {
- Assert.Contains("$.", exAsStr);
- Assert.DoesNotContain("$.Prop", exAsStr);
- }
-
- // Verify null semantics. NSE is not thrown because the serializer handles null.
- if (!type.IsValueType || isNullableOfT)
- {
- string serialized = await Serializer.SerializeWrapper<T>((T)(object)null);
- Assert.Equal("null", serialized);
-
- obj.Prop = (T)(object)null;
- serialized = await Serializer.SerializeWrapper(obj);
- Assert.Equal(@"{""Prop"":null}", serialized);
-
- serialized = await Serializer.SerializeWrapper(obj, new JsonSerializerOptions { IgnoreNullValues = true });
- Assert.Equal(@"{}", serialized);
- }
+ Assert.Contains("$.", exAsStr);
+ Assert.DoesNotContain("$.Prop", exAsStr);
+ }
+
+ // Verify null semantics. NSE is not thrown because the serializer handles null.
+ if (!type.IsValueType || isNullableOfT)
+ {
+ string serialized = await Serializer.SerializeWrapper<T>((T)(object)null);
+ Assert.Equal("null", serialized);
+
+ obj.Prop = (T)(object)null;
+ serialized = await Serializer.SerializeWrapper(obj);
+ Assert.Equal(@"{""Prop"":null}", serialized);
+
+ serialized = await Serializer.SerializeWrapper(obj, new JsonSerializerOptions { IgnoreNullValues = true });
+ Assert.Equal(@"{}", serialized);
+ }
 
 #if !BUILDING_SOURCE_GENERATOR_TESTS
-Type runtimeType = GetNullableOfTUnderlyingType(value.GetType(), out bool _);
+ Type runtimeType = GetNullableOfTUnderlyingType(value.GetType(), out bool _);
 
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper<object>(value));
-exAsStr = ex.ToString();
-Assert.Contains(runtimeType.FullName, exAsStr);
-Assert.Contains("$", exAsStr);
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper<object>(value));
+ exAsStr = ex.ToString();
+ Assert.Contains(runtimeType.FullName, exAsStr);
+ Assert.Contains("$", exAsStr);
 
-ClassWithType<object> polyObj = new ClassWithType<object> { Prop = value };
-ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(polyObj));
-exAsStr = ex.ToString();
-Assert.Contains(runtimeType.FullName, exAsStr);
+ ClassWithType<object> polyObj = new ClassWithType<object> { Prop = value };
+ ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await Serializer.SerializeWrapper(polyObj));
+ exAsStr = ex.ToString();
+ Assert.Contains(runtimeType.FullName, exAsStr);
 #endif
- }
+ }
+
+ public static IEnumerable<object[]> GetUnsupportedValues()
+ {
+ yield return WrapArgs(typeof(int));
+ yield return WrapArgs(typeof(ClassWithExtensionProperty).GetConstructor(Array.Empty<Type>()));
+ yield return WrapArgs(typeof(ClassWithExtensionProperty).GetProperty(nameof(ClassWithExtensionProperty.MyInt)));
+ yield return WrapArgs(new SerializationInfo(typeof(Type), new FormatterConverter()));
+ yield return WrapArgs((IntPtr)123);
+ yield return WrapArgs<IntPtr?>(new IntPtr(123)); // One nullable variation.
+ yield return WrapArgs((UIntPtr)123);
+
+ static object[] WrapArgs<T>(T value) => new object[] { new ValueWrapper<T>(value) };
+ }
+
+ // Helper record used to path both value & type information to generic theories.
+ // This is needed e.g. when passing System.Type instances whose runtime type
+ // actually is System.Reflection.RuntimeType.
+ public record ValueWrapper<T>(T value)
+ {
+ public override string ToString() => value.ToString();
  }
 
  public class ClassWithIntPtr
@@ -151,6 +159,21 @@ public override void Write(Utf8JsonWriter writer, IntPtr value, JsonSerializerOp
  }
  }
 
+#if !BUILDING_SOURCE_GENERATOR_TESTS
+ [Fact]
+ public async Task TypeWithNullConstructorParameterName_ThrowsNotSupportedException()
+ {
+ // Regression test for https://github.com/dotnet/runtime/issues/58690
+ Type type = Assembly.GetExecutingAssembly().GetType("System.Runtime.CompilerServices.NullableContextAttribute")!;
+ ConstructorInfo ctorInfo = type.GetConstructor(new Type[] { typeof(byte) });
+ Assert.True(string.IsNullOrEmpty(ctorInfo.GetParameters()[0].Name));
+ object value = ctorInfo.Invoke(new object[] { (byte)0 });
+
+ await Assert.ThrowsAnyAsync<NotSupportedException>(() => Serializer.SerializeWrapper(value));
+ await Assert.ThrowsAnyAsync<NotSupportedException>(() => Serializer.DeserializeWrapper("{}", type));
+ }
+#endif
+
  [Fact]
  public async Task RuntimeConverterIsSupported_IntPtr()
  {