[STJ] Add support for nullable reference annotations on properties

src/libraries/System.Private.CoreLib/src/System/Reflection/NullabilityInfo.cs

@@ -8,7 +8,12 @@ namespace System.Reflection
  /// <summary>
  /// A class that represents nullability info
  /// </summary>
- public sealed class NullabilityInfo
+#if NET
+ public
+#else
+ internal
+#endif
+ sealed class NullabilityInfo
  {
  internal NullabilityInfo(Type type, NullabilityState readState, NullabilityState writeState,
  NullabilityInfo? elementType, NullabilityInfo[] typeArguments)
@@ -46,7 +51,12 @@ internal NullabilityInfo(Type type, NullabilityState readState, NullabilityState
  /// <summary>
  /// An enum that represents nullability state
  /// </summary>
- public enum NullabilityState
+#if NET
+ public
+#else
+ internal
+#endif
+ enum NullabilityState
  {
  /// <summary>
  /// Nullability context not enabled (oblivious)

src/libraries/System.Private.CoreLib/src/System/Reflection/NullabilityInfoContext.cs

@@ -11,7 +11,12 @@ namespace System.Reflection
  /// Provides APIs for populating nullability information/context from reflection members:
  /// <see cref="ParameterInfo"/>, <see cref="FieldInfo"/>, <see cref="PropertyInfo"/> and <see cref="EventInfo"/>.
  /// </summary>
- public sealed class NullabilityInfoContext
+#if NET
+ public
+#else
+ internal
+#endif
+ sealed class NullabilityInfoContext
  {
  private const string CompilerServicesNameSpace = "System.Runtime.CompilerServices";
  private readonly Dictionary<Module, NotAnnotatedStatus> _publicOnlyModules = new();
@@ -65,7 +70,11 @@ private enum NotAnnotatedStatus
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(ParameterInfo parameterInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(parameterInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(parameterInfo, nameof(parameterInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -190,7 +199,11 @@ private static void CheckNullabilityAttributes(NullabilityInfo nullability, ILis
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(PropertyInfo propertyInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(propertyInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(propertyInfo, nameof(propertyInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -212,7 +225,9 @@ public NullabilityInfo Create(PropertyInfo propertyInfo)
 
  if (setter != null)
  {
- CheckNullabilityAttributes(nullability, setter.GetParametersAsSpan()[^1].GetCustomAttributesData());
+ ReadOnlySpan<ParameterInfo> parameters = setter.GetParametersAsSpan();
+ ParameterInfo parameter = parameters[parameters.Length - 1];
+ CheckNullabilityAttributes(nullability, parameter.GetCustomAttributesData());
  }
  else
  {
@@ -243,7 +258,11 @@ private bool IsPrivateOrInternalMethodAndAnnotationDisabled(MethodBase method)
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(EventInfo eventInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(eventInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(eventInfo, nameof(eventInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -260,7 +279,11 @@ public NullabilityInfo Create(EventInfo eventInfo)
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(FieldInfo fieldInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(fieldInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(fieldInfo, nameof(fieldInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -497,7 +520,11 @@ private bool TryUpdateGenericParameterNullability(NullabilityInfo nullability, T
  Debug.Assert(genericParameter.IsGenericParameter);
 
  if (reflectedType is not null
+#if NET
  && !genericParameter.IsGenericMethodParameter
+#else
+ && !genericParameter.IsGenericMethodParameter()
+#endif
  && TryUpdateGenericTypeParameterNullabilityFromReflectedType(nullability, genericParameter, reflectedType, reflectedType))
  {
  return true;
@@ -528,7 +555,12 @@ private bool TryUpdateGenericParameterNullability(NullabilityInfo nullability, T
 
  private bool TryUpdateGenericTypeParameterNullabilityFromReflectedType(NullabilityInfo nullability, Type genericParameter, Type context, Type reflectedType)
  {
- Debug.Assert(genericParameter.IsGenericParameter && !genericParameter.IsGenericMethodParameter);
+ Debug.Assert(genericParameter.IsGenericParameter &&
+#if NET
+ !genericParameter.IsGenericMethodParameter);
+#else
+ !genericParameter.IsGenericMethodParameter());
+#endif
 
  Type contextTypeDefinition = context.IsGenericType && !context.IsGenericTypeDefinition ? context.GetGenericTypeDefinition() : context;
  if (genericParameter.DeclaringType == contextTypeDefinition)
@@ -666,4 +698,54 @@ public bool ParseNullableState(int index, ref NullabilityState state)
  }
  }
  }
+
+#if !NET
+ internal static class NetstandardHelpers
+ {
+ public static void ThrowIfNull(object? argument, string paramName)
+ {
+ if (argument is null)
+ {
+ Throw(paramName);
+ static void Throw(string paramName) => throw new ArgumentNullException(paramName);
+ }
+ }
+
+ [Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern",
+ Justification = "This is finding the MemberInfo with the same MetadataToken as specified MemberInfo. If the specified MemberInfo " +
+ "exists and wasn't trimmed, then the current Type's MemberInfo couldn't have been trimmed.")]
+ public static MemberInfo GetMemberWithSameMetadataDefinitionAs(this Type type, MemberInfo member)
+ {
+ ThrowIfNull(member, nameof(member));
+
+ const BindingFlags all = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance;
+ foreach (MemberInfo myMemberInfo in type.GetMembers(all))
+ {
+ if (myMemberInfo.HasSameMetadataDefinitionAs(member))
+ {
+ return myMemberInfo;
+ }
+ }
+
+ throw new MissingMemberException(type.FullName, member.Name);
+ }
+
+ private static bool HasSameMetadataDefinitionAs(this MemberInfo info, MemberInfo other)
+ {
+ if (info.MetadataToken != other.MetadataToken)
+ return false;
+
+ if (!info.Module.Equals(other.Module))
+ return false;
+
+ return true;
+ }
+
+ public static bool IsGenericMethodParameter(this Type type)
+ => type.IsGenericParameter && type.DeclaringMethod is not null;
+
+ public static ReadOnlySpan<ParameterInfo> GetParametersAsSpan(this MethodBase metaMethod)
+ => metaMethod.GetParameters();
+ }
+#endif
 }

src/libraries/System.Text.Json/Common/JsonSourceGenerationOptionsAttribute.cs

@@ -115,6 +115,11 @@ public JsonSourceGenerationOptionsAttribute(JsonSerializerDefaults defaults)
  /// </summary>
  public JsonCommentHandling ReadCommentHandling { get; set; }
 
+ /// <summary>
+ /// Specifies the default value of <see cref="JsonSerializerOptions.RespectNullableAnnotations"/> when set.
+ /// </summary>
+ public bool RespectNullableAnnotations { get; set; }
+
  /// <summary>
  /// Specifies the default value of <see cref="JsonSerializerOptions.UnknownTypeHandling"/> when set.
  /// </summary>

src/libraries/System.Text.Json/gen/Helpers/RoslynExtensions.cs

@@ -50,6 +50,12 @@ public static ITypeSymbol EraseCompileTimeMetadata(this Compilation compilation,
  type = type.WithNullableAnnotation(NullableAnnotation.None);
  }
 
+ if (type is IArrayTypeSymbol arrayType)
+ {
+ ITypeSymbol elementType = compilation.EraseCompileTimeMetadata(arrayType.ElementType);
+ return compilation.CreateArrayTypeSymbol(elementType, arrayType.Rank);
+ }
+
  if (type is INamedTypeSymbol namedType)
  {
  if (namedType.IsTupleType)
@@ -189,6 +195,9 @@ SpecialType.System_Byte or SpecialType.System_UInt16 or SpecialType.System_UInt3
  SpecialType.System_Single or SpecialType.System_Double or SpecialType.System_Decimal;
  }
 
+ public static bool IsNullableType(this ITypeSymbol type)
+ => !type.IsValueType || type.OriginalDefinition.SpecialType is SpecialType.System_Nullable_T;
+
  public static bool IsNullableValueType(this ITypeSymbol type, [NotNullWhen(true)] out ITypeSymbol? elementType)
  {
  if (type.IsValueType && type is INamedTypeSymbol { OriginalDefinition.SpecialType: SpecialType.System_Nullable_T })
@@ -269,5 +278,107 @@ public static string GetTypeKindKeyword(this TypeDeclarationSyntax typeDeclarati
  return null;
  }
  }
+
+ public static void ResolveNullabilityAnnotations(this IFieldSymbol field, out bool isGetterNonNullable, out bool isSetterNonNullable)
+ {
+ if (field.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not its instantiation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ field = field.OriginalDefinition;
+
+ isGetterNonNullable = IsOutputTypeNonNullable(field, field.Type);
+ isSetterNonNullable = IsInputTypeNonNullable(field, field.Type);
+ }
+ else
+ {
+ isGetterNonNullable = isSetterNonNullable = false;
+ }
+ }
+
+ public static void ResolveNullabilityAnnotations(this IPropertySymbol property, out bool isGetterNonNullable, out bool isSetterNonNullable)
+ {
+ if (property.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not its instantiation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ property = property.OriginalDefinition;
+
+ isGetterNonNullable = property.GetMethod != null && IsOutputTypeNonNullable(property, property.Type);
+ isSetterNonNullable = property.SetMethod != null && IsInputTypeNonNullable(property, property.Type);
+ }
+ else
+ {
+ isGetterNonNullable = isSetterNonNullable = false;
+ }
+ }
+
+ public static bool IsNullable(this IParameterSymbol parameter)
+ {
+ if (parameter.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not instation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ parameter = parameter.OriginalDefinition;
+ return !IsInputTypeNonNullable(parameter, parameter.Type);
+ }
+
+ return false;
+ }
+
+ private static bool IsOutputTypeNonNullable(this ISymbol symbol, ITypeSymbol returnType)
+ {
+ if (symbol.HasCodeAnalysisAttribute("MaybeNullAttribute"))
+ {
+ return false;
+ }
+
+ if (symbol.HasCodeAnalysisAttribute("NotNullAttribute"))
+ {
+ return true;
+ }
+
+ if (returnType is ITypeParameterSymbol { HasNotNullConstraint: false })
+ {
+ return false;
+ }
+
+ return returnType.NullableAnnotation is NullableAnnotation.NotAnnotated;
+ }
+
+ private static bool IsInputTypeNonNullable(this ISymbol symbol, ITypeSymbol inputType)
+ {
+ Debug.Assert(inputType.IsNullableType());
+
+ if (symbol.HasCodeAnalysisAttribute("AllowNullAttribute"))
+ {
+ return false;
+ }
+
+ if (symbol.HasCodeAnalysisAttribute("DisallowNullAttribute"))
+ {
+ return true;
+ }
+
+ if (inputType is ITypeParameterSymbol { HasNotNullConstraint: false })
+ {
+ return false;
+ }
+
+ return inputType.NullableAnnotation is NullableAnnotation.NotAnnotated;
+ }
+
+ private static bool HasCodeAnalysisAttribute(this ISymbol symbol, string attributeName)
+ {
+ return symbol.GetAttributes().Any(attr =>
+ attr.AttributeClass?.Name == attributeName &&
+ attr.AttributeClass.ContainingNamespace.ToDisplayString() == "System.Diagnostics.CodeAnalysis");
+ }
  }
 }

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

@@ -30,6 +30,9 @@ private static class ExceptionMessages
 
  public const string InvalidSerializablePropertyConfiguration =
  "Invalid serializable-property configuration specified for type '{0}'. For more information, see 'JsonSourceGenerationMode.Serialization'.";
+
+ public const string PropertyGetterDisallowNull =
+ "The property or field '{0}' on type '{1}' doesn't allow getting null values. Consider updating its nullability annotation.";
  };
  }
  }

src/libraries/System.Private.CoreLib/src/System/Reflection/NullabilityInfo.cs

@@ -8,7 +8,12 @@ namespace System.Reflection
  /// <summary>
  /// A class that represents nullability info
  /// </summary>
- public sealed class NullabilityInfo
+#if NET
+ public
+#else
+ internal
+#endif
+ sealed class NullabilityInfo
  {
  internal NullabilityInfo(Type type, NullabilityState readState, NullabilityState writeState,
  NullabilityInfo? elementType, NullabilityInfo[] typeArguments)
@@ -46,7 +51,12 @@ internal NullabilityInfo(Type type, NullabilityState readState, NullabilityState
  /// <summary>
  /// An enum that represents nullability state
  /// </summary>
- public enum NullabilityState
+#if NET
+ public
+#else
+ internal
+#endif
+ enum NullabilityState
  {
  /// <summary>
  /// Nullability context not enabled (oblivious)

src/libraries/System.Private.CoreLib/src/System/Reflection/NullabilityInfoContext.cs

@@ -11,7 +11,12 @@ namespace System.Reflection
  /// Provides APIs for populating nullability information/context from reflection members:
  /// <see cref="ParameterInfo"/>, <see cref="FieldInfo"/>, <see cref="PropertyInfo"/> and <see cref="EventInfo"/>.
  /// </summary>
- public sealed class NullabilityInfoContext
+#if NET
+ public
+#else
+ internal
+#endif
+ sealed class NullabilityInfoContext
  {
  private const string CompilerServicesNameSpace = "System.Runtime.CompilerServices";
  private readonly Dictionary<Module, NotAnnotatedStatus> _publicOnlyModules = new();
@@ -65,7 +70,11 @@ private enum NotAnnotatedStatus
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(ParameterInfo parameterInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(parameterInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(parameterInfo, nameof(parameterInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -190,7 +199,11 @@ private static void CheckNullabilityAttributes(NullabilityInfo nullability, ILis
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(PropertyInfo propertyInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(propertyInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(propertyInfo, nameof(propertyInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -212,7 +225,9 @@ public NullabilityInfo Create(PropertyInfo propertyInfo)
 
  if (setter != null)
  {
- CheckNullabilityAttributes(nullability, setter.GetParametersAsSpan()[^1].GetCustomAttributesData());
+ ReadOnlySpan<ParameterInfo> parameters = setter.GetParametersAsSpan();
+ ParameterInfo parameter = parameters[parameters.Length - 1];
+ CheckNullabilityAttributes(nullability, parameter.GetCustomAttributesData());
  }
  else
  {
@@ -243,7 +258,11 @@ private bool IsPrivateOrInternalMethodAndAnnotationDisabled(MethodBase method)
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(EventInfo eventInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(eventInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(eventInfo, nameof(eventInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -260,7 +279,11 @@ public NullabilityInfo Create(EventInfo eventInfo)
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(FieldInfo fieldInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(fieldInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(fieldInfo, nameof(fieldInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -497,7 +520,11 @@ private bool TryUpdateGenericParameterNullability(NullabilityInfo nullability, T
  Debug.Assert(genericParameter.IsGenericParameter);
 
  if (reflectedType is not null
+#if NET
  && !genericParameter.IsGenericMethodParameter
+#else
+ && !genericParameter.IsGenericMethodParameter()
+#endif
  && TryUpdateGenericTypeParameterNullabilityFromReflectedType(nullability, genericParameter, reflectedType, reflectedType))
  {
  return true;
@@ -528,7 +555,12 @@ private bool TryUpdateGenericParameterNullability(NullabilityInfo nullability, T
 
  private bool TryUpdateGenericTypeParameterNullabilityFromReflectedType(NullabilityInfo nullability, Type genericParameter, Type context, Type reflectedType)
  {
- Debug.Assert(genericParameter.IsGenericParameter && !genericParameter.IsGenericMethodParameter);
+ Debug.Assert(genericParameter.IsGenericParameter &&
+#if NET
+ !genericParameter.IsGenericMethodParameter);
+#else
+ !genericParameter.IsGenericMethodParameter());
+#endif
 
  Type contextTypeDefinition = context.IsGenericType && !context.IsGenericTypeDefinition ? context.GetGenericTypeDefinition() : context;
  if (genericParameter.DeclaringType == contextTypeDefinition)
@@ -666,4 +698,54 @@ public bool ParseNullableState(int index, ref NullabilityState state)
  }
  }
  }
+
+#if !NET
+ internal static class NetstandardHelpers
+ {
+ public static void ThrowIfNull(object? argument, string paramName)
+ {
+ if (argument is null)
+ {
+ Throw(paramName);
+ static void Throw(string paramName) => throw new ArgumentNullException(paramName);
+ }
+ }
+
+ [Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern",
+ Justification = "This is finding the MemberInfo with the same MetadataToken as specified MemberInfo. If the specified MemberInfo " +
+ "exists and wasn't trimmed, then the current Type's MemberInfo couldn't have been trimmed.")]
+ public static MemberInfo GetMemberWithSameMetadataDefinitionAs(this Type type, MemberInfo member)
+ {
+ ThrowIfNull(member, nameof(member));
+
+ const BindingFlags all = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance;
+ foreach (MemberInfo myMemberInfo in type.GetMembers(all))
+ {
+ if (myMemberInfo.HasSameMetadataDefinitionAs(member))
+ {
+ return myMemberInfo;
+ }
+ }
+
+ throw new MissingMemberException(type.FullName, member.Name);
+ }
+
+ private static bool HasSameMetadataDefinitionAs(this MemberInfo info, MemberInfo other)
+ {
+ if (info.MetadataToken != other.MetadataToken)
+ return false;
+
+ if (!info.Module.Equals(other.Module))
+ return false;
+
+ return true;
+ }
+
+ public static bool IsGenericMethodParameter(this Type type)
+ => type.IsGenericParameter && type.DeclaringMethod is not null;
+
+ public static ReadOnlySpan<ParameterInfo> GetParametersAsSpan(this MethodBase metaMethod)
+ => metaMethod.GetParameters();
+ }
+#endif
 }

src/libraries/System.Text.Json/Common/JsonSourceGenerationOptionsAttribute.cs

@@ -115,6 +115,11 @@ public JsonSourceGenerationOptionsAttribute(JsonSerializerDefaults defaults)
  /// </summary>
  public JsonCommentHandling ReadCommentHandling { get; set; }
 
+ /// <summary>
+ /// Specifies the default value of <see cref="JsonSerializerOptions.RespectNullableAnnotations"/> when set.
+ /// </summary>
+ public bool RespectNullableAnnotations { get; set; }
+
  /// <summary>
  /// Specifies the default value of <see cref="JsonSerializerOptions.UnknownTypeHandling"/> when set.
  /// </summary>

src/libraries/System.Text.Json/gen/Helpers/RoslynExtensions.cs

@@ -50,6 +50,12 @@ public static ITypeSymbol EraseCompileTimeMetadata(this Compilation compilation,
  type = type.WithNullableAnnotation(NullableAnnotation.None);
  }
 
+ if (type is IArrayTypeSymbol arrayType)
+ {
+ ITypeSymbol elementType = compilation.EraseCompileTimeMetadata(arrayType.ElementType);
+ return compilation.CreateArrayTypeSymbol(elementType, arrayType.Rank);
+ }
+
  if (type is INamedTypeSymbol namedType)
  {
  if (namedType.IsTupleType)
@@ -189,6 +195,9 @@ SpecialType.System_Byte or SpecialType.System_UInt16 or SpecialType.System_UInt3
  SpecialType.System_Single or SpecialType.System_Double or SpecialType.System_Decimal;
  }
 
+ public static bool IsNullableType(this ITypeSymbol type)
+ => !type.IsValueType || type.OriginalDefinition.SpecialType is SpecialType.System_Nullable_T;
+
  public static bool IsNullableValueType(this ITypeSymbol type, [NotNullWhen(true)] out ITypeSymbol? elementType)
  {
  if (type.IsValueType && type is INamedTypeSymbol { OriginalDefinition.SpecialType: SpecialType.System_Nullable_T })
@@ -269,5 +278,107 @@ public static string GetTypeKindKeyword(this TypeDeclarationSyntax typeDeclarati
  return null;
  }
  }
+
+ public static void ResolveNullabilityAnnotations(this IFieldSymbol field, out bool isGetterNonNullable, out bool isSetterNonNullable)
+ {
+ if (field.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not its instantiation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ field = field.OriginalDefinition;
+
+ isGetterNonNullable = IsOutputTypeNonNullable(field, field.Type);
+ isSetterNonNullable = IsInputTypeNonNullable(field, field.Type);
+ }
+ else
+ {
+ isGetterNonNullable = isSetterNonNullable = false;
+ }
+ }
+
+ public static void ResolveNullabilityAnnotations(this IPropertySymbol property, out bool isGetterNonNullable, out bool isSetterNonNullable)
+ {
+ if (property.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not its instantiation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ property = property.OriginalDefinition;
+
+ isGetterNonNullable = property.GetMethod != null && IsOutputTypeNonNullable(property, property.Type);
+ isSetterNonNullable = property.SetMethod != null && IsInputTypeNonNullable(property, property.Type);
+ }
+ else
+ {
+ isGetterNonNullable = isSetterNonNullable = false;
+ }
+ }
+
+ public static bool IsNullable(this IParameterSymbol parameter)
+ {
+ if (parameter.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not instation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ parameter = parameter.OriginalDefinition;
+ return !IsInputTypeNonNullable(parameter, parameter.Type);
+ }
+
+ return false;
+ }
+
+ private static bool IsOutputTypeNonNullable(this ISymbol symbol, ITypeSymbol returnType)
+ {
+ if (symbol.HasCodeAnalysisAttribute("MaybeNullAttribute"))
+ {
+ return false;
+ }
+
+ if (symbol.HasCodeAnalysisAttribute("NotNullAttribute"))
+ {
+ return true;
+ }
+
+ if (returnType is ITypeParameterSymbol { HasNotNullConstraint: false })
+ {
+ return false;
+ }
+
+ return returnType.NullableAnnotation is NullableAnnotation.NotAnnotated;
+ }
+
+ private static bool IsInputTypeNonNullable(this ISymbol symbol, ITypeSymbol inputType)
+ {
+ Debug.Assert(inputType.IsNullableType());
+
+ if (symbol.HasCodeAnalysisAttribute("AllowNullAttribute"))
+ {
+ return false;
+ }
+
+ if (symbol.HasCodeAnalysisAttribute("DisallowNullAttribute"))
+ {
+ return true;
+ }
+
+ if (inputType is ITypeParameterSymbol { HasNotNullConstraint: false })
+ {
+ return false;
+ }
+
+ return inputType.NullableAnnotation is NullableAnnotation.NotAnnotated;
+ }
+
+ private static bool HasCodeAnalysisAttribute(this ISymbol symbol, string attributeName)
+ {
+ return symbol.GetAttributes().Any(attr =>
+ attr.AttributeClass?.Name == attributeName &&
+ attr.AttributeClass.ContainingNamespace.ToDisplayString() == "System.Diagnostics.CodeAnalysis");
+ }
  }
 }

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

@@ -30,6 +30,9 @@ private static class ExceptionMessages
 
  public const string InvalidSerializablePropertyConfiguration =
  "Invalid serializable-property configuration specified for type '{0}'. For more information, see 'JsonSourceGenerationMode.Serialization'.";
+
+ public const string PropertyGetterDisallowNull =
+ "The property or field '{0}' on type '{1}' doesn't allow getting null values. Consider updating its nullability annotation.";
  };
  }
  }

src/libraries/System.Private.CoreLib/src/System/Reflection/NullabilityInfo.cs

@@ -8,7 +8,12 @@ namespace System.Reflection
  /// <summary>
  /// A class that represents nullability info
  /// </summary>
- public sealed class NullabilityInfo
+#if NET
+ public
+#else
+ internal
+#endif
+ sealed class NullabilityInfo
  {
  internal NullabilityInfo(Type type, NullabilityState readState, NullabilityState writeState,
  NullabilityInfo? elementType, NullabilityInfo[] typeArguments)
@@ -46,7 +51,12 @@ internal NullabilityInfo(Type type, NullabilityState readState, NullabilityState
  /// <summary>
  /// An enum that represents nullability state
  /// </summary>
- public enum NullabilityState
+#if NET
+ public
+#else
+ internal
+#endif
+ enum NullabilityState
  {
  /// <summary>
  /// Nullability context not enabled (oblivious)

src/libraries/System.Private.CoreLib/src/System/Reflection/NullabilityInfoContext.cs

@@ -11,7 +11,12 @@ namespace System.Reflection
  /// Provides APIs for populating nullability information/context from reflection members:
  /// <see cref="ParameterInfo"/>, <see cref="FieldInfo"/>, <see cref="PropertyInfo"/> and <see cref="EventInfo"/>.
  /// </summary>
- public sealed class NullabilityInfoContext
+#if NET
+ public
+#else
+ internal
+#endif
+ sealed class NullabilityInfoContext
  {
  private const string CompilerServicesNameSpace = "System.Runtime.CompilerServices";
  private readonly Dictionary<Module, NotAnnotatedStatus> _publicOnlyModules = new();
@@ -65,7 +70,11 @@ private enum NotAnnotatedStatus
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(ParameterInfo parameterInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(parameterInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(parameterInfo, nameof(parameterInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -190,7 +199,11 @@ private static void CheckNullabilityAttributes(NullabilityInfo nullability, ILis
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(PropertyInfo propertyInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(propertyInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(propertyInfo, nameof(propertyInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -212,7 +225,9 @@ public NullabilityInfo Create(PropertyInfo propertyInfo)
 
  if (setter != null)
  {
- CheckNullabilityAttributes(nullability, setter.GetParametersAsSpan()[^1].GetCustomAttributesData());
+ ReadOnlySpan<ParameterInfo> parameters = setter.GetParametersAsSpan();
+ ParameterInfo parameter = parameters[parameters.Length - 1];
+ CheckNullabilityAttributes(nullability, parameter.GetCustomAttributesData());
  }
  else
  {
@@ -243,7 +258,11 @@ private bool IsPrivateOrInternalMethodAndAnnotationDisabled(MethodBase method)
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(EventInfo eventInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(eventInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(eventInfo, nameof(eventInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -260,7 +279,11 @@ public NullabilityInfo Create(EventInfo eventInfo)
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(FieldInfo fieldInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(fieldInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(fieldInfo, nameof(fieldInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -497,7 +520,11 @@ private bool TryUpdateGenericParameterNullability(NullabilityInfo nullability, T
  Debug.Assert(genericParameter.IsGenericParameter);
 
  if (reflectedType is not null
+#if NET
  && !genericParameter.IsGenericMethodParameter
+#else
+ && !genericParameter.IsGenericMethodParameter()
+#endif
  && TryUpdateGenericTypeParameterNullabilityFromReflectedType(nullability, genericParameter, reflectedType, reflectedType))
  {
  return true;
@@ -528,7 +555,12 @@ private bool TryUpdateGenericParameterNullability(NullabilityInfo nullability, T
 
  private bool TryUpdateGenericTypeParameterNullabilityFromReflectedType(NullabilityInfo nullability, Type genericParameter, Type context, Type reflectedType)
  {
- Debug.Assert(genericParameter.IsGenericParameter && !genericParameter.IsGenericMethodParameter);
+ Debug.Assert(genericParameter.IsGenericParameter &&
+#if NET
+ !genericParameter.IsGenericMethodParameter);
+#else
+ !genericParameter.IsGenericMethodParameter());
+#endif
 
  Type contextTypeDefinition = context.IsGenericType && !context.IsGenericTypeDefinition ? context.GetGenericTypeDefinition() : context;
  if (genericParameter.DeclaringType == contextTypeDefinition)
@@ -666,4 +698,54 @@ public bool ParseNullableState(int index, ref NullabilityState state)
  }
  }
  }
+
+#if !NET
+ internal static class NetstandardHelpers
+ {
+ public static void ThrowIfNull(object? argument, string paramName)
+ {
+ if (argument is null)
+ {
+ Throw(paramName);
+ static void Throw(string paramName) => throw new ArgumentNullException(paramName);
+ }
+ }
+
+ [Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern",
+ Justification = "This is finding the MemberInfo with the same MetadataToken as specified MemberInfo. If the specified MemberInfo " +
+ "exists and wasn't trimmed, then the current Type's MemberInfo couldn't have been trimmed.")]
+ public static MemberInfo GetMemberWithSameMetadataDefinitionAs(this Type type, MemberInfo member)
+ {
+ ThrowIfNull(member, nameof(member));
+
+ const BindingFlags all = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance;
+ foreach (MemberInfo myMemberInfo in type.GetMembers(all))
+ {
+ if (myMemberInfo.HasSameMetadataDefinitionAs(member))
+ {
+ return myMemberInfo;
+ }
+ }
+
+ throw new MissingMemberException(type.FullName, member.Name);
+ }
+
+ private static bool HasSameMetadataDefinitionAs(this MemberInfo info, MemberInfo other)
+ {
+ if (info.MetadataToken != other.MetadataToken)
+ return false;
+
+ if (!info.Module.Equals(other.Module))
+ return false;
+
+ return true;
+ }
+
+ public static bool IsGenericMethodParameter(this Type type)
+ => type.IsGenericParameter && type.DeclaringMethod is not null;
+
+ public static ReadOnlySpan<ParameterInfo> GetParametersAsSpan(this MethodBase metaMethod)
+ => metaMethod.GetParameters();
+ }
+#endif
 }

src/libraries/System.Text.Json/Common/JsonSourceGenerationOptionsAttribute.cs

@@ -115,6 +115,11 @@ public JsonSourceGenerationOptionsAttribute(JsonSerializerDefaults defaults)
  /// </summary>
  public JsonCommentHandling ReadCommentHandling { get; set; }
 
+ /// <summary>
+ /// Specifies the default value of <see cref="JsonSerializerOptions.RespectNullableAnnotations"/> when set.
+ /// </summary>
+ public bool RespectNullableAnnotations { get; set; }
+
  /// <summary>
  /// Specifies the default value of <see cref="JsonSerializerOptions.UnknownTypeHandling"/> when set.
  /// </summary>

src/libraries/System.Text.Json/gen/Helpers/RoslynExtensions.cs

@@ -50,6 +50,12 @@ public static ITypeSymbol EraseCompileTimeMetadata(this Compilation compilation,
  type = type.WithNullableAnnotation(NullableAnnotation.None);
  }
 
+ if (type is IArrayTypeSymbol arrayType)
+ {
+ ITypeSymbol elementType = compilation.EraseCompileTimeMetadata(arrayType.ElementType);
+ return compilation.CreateArrayTypeSymbol(elementType, arrayType.Rank);
+ }
+
  if (type is INamedTypeSymbol namedType)
  {
  if (namedType.IsTupleType)
@@ -189,6 +195,9 @@ SpecialType.System_Byte or SpecialType.System_UInt16 or SpecialType.System_UInt3
  SpecialType.System_Single or SpecialType.System_Double or SpecialType.System_Decimal;
  }
 
+ public static bool IsNullableType(this ITypeSymbol type)
+ => !type.IsValueType || type.OriginalDefinition.SpecialType is SpecialType.System_Nullable_T;
+
  public static bool IsNullableValueType(this ITypeSymbol type, [NotNullWhen(true)] out ITypeSymbol? elementType)
  {
  if (type.IsValueType && type is INamedTypeSymbol { OriginalDefinition.SpecialType: SpecialType.System_Nullable_T })
@@ -269,5 +278,107 @@ public static string GetTypeKindKeyword(this TypeDeclarationSyntax typeDeclarati
  return null;
  }
  }
+
+ public static void ResolveNullabilityAnnotations(this IFieldSymbol field, out bool isGetterNonNullable, out bool isSetterNonNullable)
+ {
+ if (field.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not its instantiation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ field = field.OriginalDefinition;
+
+ isGetterNonNullable = IsOutputTypeNonNullable(field, field.Type);
+ isSetterNonNullable = IsInputTypeNonNullable(field, field.Type);
+ }
+ else
+ {
+ isGetterNonNullable = isSetterNonNullable = false;
+ }
+ }
+
+ public static void ResolveNullabilityAnnotations(this IPropertySymbol property, out bool isGetterNonNullable, out bool isSetterNonNullable)
+ {
+ if (property.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not its instantiation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ property = property.OriginalDefinition;
+
+ isGetterNonNullable = property.GetMethod != null && IsOutputTypeNonNullable(property, property.Type);
+ isSetterNonNullable = property.SetMethod != null && IsInputTypeNonNullable(property, property.Type);
+ }
+ else
+ {
+ isGetterNonNullable = isSetterNonNullable = false;
+ }
+ }
+
+ public static bool IsNullable(this IParameterSymbol parameter)
+ {
+ if (parameter.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not instation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ parameter = parameter.OriginalDefinition;
+ return !IsInputTypeNonNullable(parameter, parameter.Type);
+ }
+
+ return false;
+ }
+
+ private static bool IsOutputTypeNonNullable(this ISymbol symbol, ITypeSymbol returnType)
+ {
+ if (symbol.HasCodeAnalysisAttribute("MaybeNullAttribute"))
+ {
+ return false;
+ }
+
+ if (symbol.HasCodeAnalysisAttribute("NotNullAttribute"))
+ {
+ return true;
+ }
+
+ if (returnType is ITypeParameterSymbol { HasNotNullConstraint: false })
+ {
+ return false;
+ }
+
+ return returnType.NullableAnnotation is NullableAnnotation.NotAnnotated;
+ }
+
+ private static bool IsInputTypeNonNullable(this ISymbol symbol, ITypeSymbol inputType)
+ {
+ Debug.Assert(inputType.IsNullableType());
+
+ if (symbol.HasCodeAnalysisAttribute("AllowNullAttribute"))
+ {
+ return false;
+ }
+
+ if (symbol.HasCodeAnalysisAttribute("DisallowNullAttribute"))
+ {
+ return true;
+ }
+
+ if (inputType is ITypeParameterSymbol { HasNotNullConstraint: false })
+ {
+ return false;
+ }
+
+ return inputType.NullableAnnotation is NullableAnnotation.NotAnnotated;
+ }
+
+ private static bool HasCodeAnalysisAttribute(this ISymbol symbol, string attributeName)
+ {
+ return symbol.GetAttributes().Any(attr =>
+ attr.AttributeClass?.Name == attributeName &&
+ attr.AttributeClass.ContainingNamespace.ToDisplayString() == "System.Diagnostics.CodeAnalysis");
+ }
  }
 }

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

@@ -30,6 +30,9 @@ private static class ExceptionMessages
 
  public const string InvalidSerializablePropertyConfiguration =
  "Invalid serializable-property configuration specified for type '{0}'. For more information, see 'JsonSourceGenerationMode.Serialization'.";
+
+ public const string PropertyGetterDisallowNull =
+ "The property or field '{0}' on type '{1}' doesn't allow getting null values. Consider updating its nullability annotation.";
  };
  }
  }

src/libraries/System.Private.CoreLib/src/System/Reflection/NullabilityInfo.cs

@@ -8,7 +8,12 @@ namespace System.Reflection
  /// <summary>
  /// A class that represents nullability info
  /// </summary>
- public sealed class NullabilityInfo
+#if NET
+ public
+#else
+ internal
+#endif
+ sealed class NullabilityInfo
  {
  internal NullabilityInfo(Type type, NullabilityState readState, NullabilityState writeState,
  NullabilityInfo? elementType, NullabilityInfo[] typeArguments)
@@ -46,7 +51,12 @@ internal NullabilityInfo(Type type, NullabilityState readState, NullabilityState
  /// <summary>
  /// An enum that represents nullability state
  /// </summary>
- public enum NullabilityState
+#if NET
+ public
+#else
+ internal
+#endif
+ enum NullabilityState
  {
  /// <summary>
  /// Nullability context not enabled (oblivious)

src/libraries/System.Private.CoreLib/src/System/Reflection/NullabilityInfoContext.cs

@@ -11,7 +11,12 @@ namespace System.Reflection
  /// Provides APIs for populating nullability information/context from reflection members:
  /// <see cref="ParameterInfo"/>, <see cref="FieldInfo"/>, <see cref="PropertyInfo"/> and <see cref="EventInfo"/>.
  /// </summary>
- public sealed class NullabilityInfoContext
+#if NET
+ public
+#else
+ internal
+#endif
+ sealed class NullabilityInfoContext
  {
  private const string CompilerServicesNameSpace = "System.Runtime.CompilerServices";
  private readonly Dictionary<Module, NotAnnotatedStatus> _publicOnlyModules = new();
@@ -65,7 +70,11 @@ private enum NotAnnotatedStatus
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(ParameterInfo parameterInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(parameterInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(parameterInfo, nameof(parameterInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -190,7 +199,11 @@ private static void CheckNullabilityAttributes(NullabilityInfo nullability, ILis
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(PropertyInfo propertyInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(propertyInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(propertyInfo, nameof(propertyInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -212,7 +225,9 @@ public NullabilityInfo Create(PropertyInfo propertyInfo)
 
  if (setter != null)
  {
- CheckNullabilityAttributes(nullability, setter.GetParametersAsSpan()[^1].GetCustomAttributesData());
+ ReadOnlySpan<ParameterInfo> parameters = setter.GetParametersAsSpan();
+ ParameterInfo parameter = parameters[parameters.Length - 1];
+ CheckNullabilityAttributes(nullability, parameter.GetCustomAttributesData());
  }
  else
  {
@@ -243,7 +258,11 @@ private bool IsPrivateOrInternalMethodAndAnnotationDisabled(MethodBase method)
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(EventInfo eventInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(eventInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(eventInfo, nameof(eventInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -260,7 +279,11 @@ public NullabilityInfo Create(EventInfo eventInfo)
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(FieldInfo fieldInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(fieldInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(fieldInfo, nameof(fieldInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -497,7 +520,11 @@ private bool TryUpdateGenericParameterNullability(NullabilityInfo nullability, T
  Debug.Assert(genericParameter.IsGenericParameter);
 
  if (reflectedType is not null
+#if NET
  && !genericParameter.IsGenericMethodParameter
+#else
+ && !genericParameter.IsGenericMethodParameter()
+#endif
  && TryUpdateGenericTypeParameterNullabilityFromReflectedType(nullability, genericParameter, reflectedType, reflectedType))
  {
  return true;
@@ -528,7 +555,12 @@ private bool TryUpdateGenericParameterNullability(NullabilityInfo nullability, T
 
  private bool TryUpdateGenericTypeParameterNullabilityFromReflectedType(NullabilityInfo nullability, Type genericParameter, Type context, Type reflectedType)
  {
- Debug.Assert(genericParameter.IsGenericParameter && !genericParameter.IsGenericMethodParameter);
+ Debug.Assert(genericParameter.IsGenericParameter &&
+#if NET
+ !genericParameter.IsGenericMethodParameter);
+#else
+ !genericParameter.IsGenericMethodParameter());
+#endif
 
  Type contextTypeDefinition = context.IsGenericType && !context.IsGenericTypeDefinition ? context.GetGenericTypeDefinition() : context;
  if (genericParameter.DeclaringType == contextTypeDefinition)
@@ -666,4 +698,54 @@ public bool ParseNullableState(int index, ref NullabilityState state)
  }
  }
  }
+
+#if !NET
+ internal static class NetstandardHelpers
+ {
+ public static void ThrowIfNull(object? argument, string paramName)
+ {
+ if (argument is null)
+ {
+ Throw(paramName);
+ static void Throw(string paramName) => throw new ArgumentNullException(paramName);
+ }
+ }
+
+ [Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern",
+ Justification = "This is finding the MemberInfo with the same MetadataToken as specified MemberInfo. If the specified MemberInfo " +
+ "exists and wasn't trimmed, then the current Type's MemberInfo couldn't have been trimmed.")]
+ public static MemberInfo GetMemberWithSameMetadataDefinitionAs(this Type type, MemberInfo member)
+ {
+ ThrowIfNull(member, nameof(member));
+
+ const BindingFlags all = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance;
+ foreach (MemberInfo myMemberInfo in type.GetMembers(all))
+ {
+ if (myMemberInfo.HasSameMetadataDefinitionAs(member))
+ {
+ return myMemberInfo;
+ }
+ }
+
+ throw new MissingMemberException(type.FullName, member.Name);
+ }
+
+ private static bool HasSameMetadataDefinitionAs(this MemberInfo info, MemberInfo other)
+ {
+ if (info.MetadataToken != other.MetadataToken)
+ return false;
+
+ if (!info.Module.Equals(other.Module))
+ return false;
+
+ return true;
+ }
+
+ public static bool IsGenericMethodParameter(this Type type)
+ => type.IsGenericParameter && type.DeclaringMethod is not null;
+
+ public static ReadOnlySpan<ParameterInfo> GetParametersAsSpan(this MethodBase metaMethod)
+ => metaMethod.GetParameters();
+ }
+#endif
 }

src/libraries/System.Text.Json/Common/JsonSourceGenerationOptionsAttribute.cs

@@ -115,6 +115,11 @@ public JsonSourceGenerationOptionsAttribute(JsonSerializerDefaults defaults)
  /// </summary>
  public JsonCommentHandling ReadCommentHandling { get; set; }
 
+ /// <summary>
+ /// Specifies the default value of <see cref="JsonSerializerOptions.RespectNullableAnnotations"/> when set.
+ /// </summary>
+ public bool RespectNullableAnnotations { get; set; }
+
  /// <summary>
  /// Specifies the default value of <see cref="JsonSerializerOptions.UnknownTypeHandling"/> when set.
  /// </summary>

src/libraries/System.Text.Json/gen/Helpers/RoslynExtensions.cs

@@ -50,6 +50,12 @@ public static ITypeSymbol EraseCompileTimeMetadata(this Compilation compilation,
  type = type.WithNullableAnnotation(NullableAnnotation.None);
  }
 
+ if (type is IArrayTypeSymbol arrayType)
+ {
+ ITypeSymbol elementType = compilation.EraseCompileTimeMetadata(arrayType.ElementType);
+ return compilation.CreateArrayTypeSymbol(elementType, arrayType.Rank);
+ }
+
  if (type is INamedTypeSymbol namedType)
  {
  if (namedType.IsTupleType)
@@ -189,6 +195,9 @@ SpecialType.System_Byte or SpecialType.System_UInt16 or SpecialType.System_UInt3
  SpecialType.System_Single or SpecialType.System_Double or SpecialType.System_Decimal;
  }
 
+ public static bool IsNullableType(this ITypeSymbol type)
+ => !type.IsValueType || type.OriginalDefinition.SpecialType is SpecialType.System_Nullable_T;
+
  public static bool IsNullableValueType(this ITypeSymbol type, [NotNullWhen(true)] out ITypeSymbol? elementType)
  {
  if (type.IsValueType && type is INamedTypeSymbol { OriginalDefinition.SpecialType: SpecialType.System_Nullable_T })
@@ -269,5 +278,107 @@ public static string GetTypeKindKeyword(this TypeDeclarationSyntax typeDeclarati
  return null;
  }
  }
+
+ public static void ResolveNullabilityAnnotations(this IFieldSymbol field, out bool isGetterNonNullable, out bool isSetterNonNullable)
+ {
+ if (field.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not its instantiation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ field = field.OriginalDefinition;
+
+ isGetterNonNullable = IsOutputTypeNonNullable(field, field.Type);
+ isSetterNonNullable = IsInputTypeNonNullable(field, field.Type);
+ }
+ else
+ {
+ isGetterNonNullable = isSetterNonNullable = false;
+ }
+ }
+
+ public static void ResolveNullabilityAnnotations(this IPropertySymbol property, out bool isGetterNonNullable, out bool isSetterNonNullable)
+ {
+ if (property.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not its instantiation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ property = property.OriginalDefinition;
+
+ isGetterNonNullable = property.GetMethod != null && IsOutputTypeNonNullable(property, property.Type);
+ isSetterNonNullable = property.SetMethod != null && IsInputTypeNonNullable(property, property.Type);
+ }
+ else
+ {
+ isGetterNonNullable = isSetterNonNullable = false;
+ }
+ }
+
+ public static bool IsNullable(this IParameterSymbol parameter)
+ {
+ if (parameter.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not instation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ parameter = parameter.OriginalDefinition;
+ return !IsInputTypeNonNullable(parameter, parameter.Type);
+ }
+
+ return false;
+ }
+
+ private static bool IsOutputTypeNonNullable(this ISymbol symbol, ITypeSymbol returnType)
+ {
+ if (symbol.HasCodeAnalysisAttribute("MaybeNullAttribute"))
+ {
+ return false;
+ }
+
+ if (symbol.HasCodeAnalysisAttribute("NotNullAttribute"))
+ {
+ return true;
+ }
+
+ if (returnType is ITypeParameterSymbol { HasNotNullConstraint: false })
+ {
+ return false;
+ }
+
+ return returnType.NullableAnnotation is NullableAnnotation.NotAnnotated;
+ }
+
+ private static bool IsInputTypeNonNullable(this ISymbol symbol, ITypeSymbol inputType)
+ {
+ Debug.Assert(inputType.IsNullableType());
+
+ if (symbol.HasCodeAnalysisAttribute("AllowNullAttribute"))
+ {
+ return false;
+ }
+
+ if (symbol.HasCodeAnalysisAttribute("DisallowNullAttribute"))
+ {
+ return true;
+ }
+
+ if (inputType is ITypeParameterSymbol { HasNotNullConstraint: false })
+ {
+ return false;
+ }
+
+ return inputType.NullableAnnotation is NullableAnnotation.NotAnnotated;
+ }
+
+ private static bool HasCodeAnalysisAttribute(this ISymbol symbol, string attributeName)
+ {
+ return symbol.GetAttributes().Any(attr =>
+ attr.AttributeClass?.Name == attributeName &&
+ attr.AttributeClass.ContainingNamespace.ToDisplayString() == "System.Diagnostics.CodeAnalysis");
+ }
  }
 }

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

@@ -30,6 +30,9 @@ private static class ExceptionMessages
 
  public const string InvalidSerializablePropertyConfiguration =
  "Invalid serializable-property configuration specified for type '{0}'. For more information, see 'JsonSourceGenerationMode.Serialization'.";
+
+ public const string PropertyGetterDisallowNull =
+ "The property or field '{0}' on type '{1}' doesn't allow getting null values. Consider updating its nullability annotation.";
  };
  }
  }

src/libraries/System.Private.CoreLib/src/System/Reflection/NullabilityInfo.cs

@@ -8,7 +8,12 @@ namespace System.Reflection
  /// <summary>
  /// A class that represents nullability info
  /// </summary>
- public sealed class NullabilityInfo
+#if NET
+ public
+#else
+ internal
+#endif
+ sealed class NullabilityInfo
  {
  internal NullabilityInfo(Type type, NullabilityState readState, NullabilityState writeState,
  NullabilityInfo? elementType, NullabilityInfo[] typeArguments)
@@ -46,7 +51,12 @@ internal NullabilityInfo(Type type, NullabilityState readState, NullabilityState
  /// <summary>
  /// An enum that represents nullability state
  /// </summary>
- public enum NullabilityState
+#if NET
+ public
+#else
+ internal
+#endif
+ enum NullabilityState
  {
  /// <summary>
  /// Nullability context not enabled (oblivious)

src/libraries/System.Private.CoreLib/src/System/Reflection/NullabilityInfoContext.cs

@@ -11,7 +11,12 @@ namespace System.Reflection
  /// Provides APIs for populating nullability information/context from reflection members:
  /// <see cref="ParameterInfo"/>, <see cref="FieldInfo"/>, <see cref="PropertyInfo"/> and <see cref="EventInfo"/>.
  /// </summary>
- public sealed class NullabilityInfoContext
+#if NET
+ public
+#else
+ internal
+#endif
+ sealed class NullabilityInfoContext
  {
  private const string CompilerServicesNameSpace = "System.Runtime.CompilerServices";
  private readonly Dictionary<Module, NotAnnotatedStatus> _publicOnlyModules = new();
@@ -65,7 +70,11 @@ private enum NotAnnotatedStatus
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(ParameterInfo parameterInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(parameterInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(parameterInfo, nameof(parameterInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -190,7 +199,11 @@ private static void CheckNullabilityAttributes(NullabilityInfo nullability, ILis
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(PropertyInfo propertyInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(propertyInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(propertyInfo, nameof(propertyInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -212,7 +225,9 @@ public NullabilityInfo Create(PropertyInfo propertyInfo)
 
  if (setter != null)
  {
- CheckNullabilityAttributes(nullability, setter.GetParametersAsSpan()[^1].GetCustomAttributesData());
+ ReadOnlySpan<ParameterInfo> parameters = setter.GetParametersAsSpan();
+ ParameterInfo parameter = parameters[parameters.Length - 1];
+ CheckNullabilityAttributes(nullability, parameter.GetCustomAttributesData());
  }
  else
  {
@@ -243,7 +258,11 @@ private bool IsPrivateOrInternalMethodAndAnnotationDisabled(MethodBase method)
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(EventInfo eventInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(eventInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(eventInfo, nameof(eventInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -260,7 +279,11 @@ public NullabilityInfo Create(EventInfo eventInfo)
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(FieldInfo fieldInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(fieldInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(fieldInfo, nameof(fieldInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -497,7 +520,11 @@ private bool TryUpdateGenericParameterNullability(NullabilityInfo nullability, T
  Debug.Assert(genericParameter.IsGenericParameter);
 
  if (reflectedType is not null
+#if NET
  && !genericParameter.IsGenericMethodParameter
+#else
+ && !genericParameter.IsGenericMethodParameter()
+#endif
  && TryUpdateGenericTypeParameterNullabilityFromReflectedType(nullability, genericParameter, reflectedType, reflectedType))
  {
  return true;
@@ -528,7 +555,12 @@ private bool TryUpdateGenericParameterNullability(NullabilityInfo nullability, T
 
  private bool TryUpdateGenericTypeParameterNullabilityFromReflectedType(NullabilityInfo nullability, Type genericParameter, Type context, Type reflectedType)
  {
- Debug.Assert(genericParameter.IsGenericParameter && !genericParameter.IsGenericMethodParameter);
+ Debug.Assert(genericParameter.IsGenericParameter &&
+#if NET
+ !genericParameter.IsGenericMethodParameter);
+#else
+ !genericParameter.IsGenericMethodParameter());
+#endif
 
  Type contextTypeDefinition = context.IsGenericType && !context.IsGenericTypeDefinition ? context.GetGenericTypeDefinition() : context;
  if (genericParameter.DeclaringType == contextTypeDefinition)
@@ -666,4 +698,54 @@ public bool ParseNullableState(int index, ref NullabilityState state)
  }
  }
  }
+
+#if !NET
+ internal static class NetstandardHelpers
+ {
+ public static void ThrowIfNull(object? argument, string paramName)
+ {
+ if (argument is null)
+ {
+ Throw(paramName);
+ static void Throw(string paramName) => throw new ArgumentNullException(paramName);
+ }
+ }
+
+ [Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern",
+ Justification = "This is finding the MemberInfo with the same MetadataToken as specified MemberInfo. If the specified MemberInfo " +
+ "exists and wasn't trimmed, then the current Type's MemberInfo couldn't have been trimmed.")]
+ public static MemberInfo GetMemberWithSameMetadataDefinitionAs(this Type type, MemberInfo member)
+ {
+ ThrowIfNull(member, nameof(member));
+
+ const BindingFlags all = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance;
+ foreach (MemberInfo myMemberInfo in type.GetMembers(all))
+ {
+ if (myMemberInfo.HasSameMetadataDefinitionAs(member))
+ {
+ return myMemberInfo;
+ }
+ }
+
+ throw new MissingMemberException(type.FullName, member.Name);
+ }
+
+ private static bool HasSameMetadataDefinitionAs(this MemberInfo info, MemberInfo other)
+ {
+ if (info.MetadataToken != other.MetadataToken)
+ return false;
+
+ if (!info.Module.Equals(other.Module))
+ return false;
+
+ return true;
+ }
+
+ public static bool IsGenericMethodParameter(this Type type)
+ => type.IsGenericParameter && type.DeclaringMethod is not null;
+
+ public static ReadOnlySpan<ParameterInfo> GetParametersAsSpan(this MethodBase metaMethod)
+ => metaMethod.GetParameters();
+ }
+#endif
 }

src/libraries/System.Text.Json/Common/JsonSourceGenerationOptionsAttribute.cs

@@ -115,6 +115,11 @@ public JsonSourceGenerationOptionsAttribute(JsonSerializerDefaults defaults)
  /// </summary>
  public JsonCommentHandling ReadCommentHandling { get; set; }
 
+ /// <summary>
+ /// Specifies the default value of <see cref="JsonSerializerOptions.RespectNullableAnnotations"/> when set.
+ /// </summary>
+ public bool RespectNullableAnnotations { get; set; }
+
  /// <summary>
  /// Specifies the default value of <see cref="JsonSerializerOptions.UnknownTypeHandling"/> when set.
  /// </summary>

src/libraries/System.Text.Json/gen/Helpers/RoslynExtensions.cs

@@ -50,6 +50,12 @@ public static ITypeSymbol EraseCompileTimeMetadata(this Compilation compilation,
  type = type.WithNullableAnnotation(NullableAnnotation.None);
  }
 
+ if (type is IArrayTypeSymbol arrayType)
+ {
+ ITypeSymbol elementType = compilation.EraseCompileTimeMetadata(arrayType.ElementType);
+ return compilation.CreateArrayTypeSymbol(elementType, arrayType.Rank);
+ }
+
  if (type is INamedTypeSymbol namedType)
  {
  if (namedType.IsTupleType)
@@ -189,6 +195,9 @@ SpecialType.System_Byte or SpecialType.System_UInt16 or SpecialType.System_UInt3
  SpecialType.System_Single or SpecialType.System_Double or SpecialType.System_Decimal;
  }
 
+ public static bool IsNullableType(this ITypeSymbol type)
+ => !type.IsValueType || type.OriginalDefinition.SpecialType is SpecialType.System_Nullable_T;
+
  public static bool IsNullableValueType(this ITypeSymbol type, [NotNullWhen(true)] out ITypeSymbol? elementType)
  {
  if (type.IsValueType && type is INamedTypeSymbol { OriginalDefinition.SpecialType: SpecialType.System_Nullable_T })
@@ -269,5 +278,107 @@ public static string GetTypeKindKeyword(this TypeDeclarationSyntax typeDeclarati
  return null;
  }
  }
+
+ public static void ResolveNullabilityAnnotations(this IFieldSymbol field, out bool isGetterNonNullable, out bool isSetterNonNullable)
+ {
+ if (field.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not its instantiation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ field = field.OriginalDefinition;
+
+ isGetterNonNullable = IsOutputTypeNonNullable(field, field.Type);
+ isSetterNonNullable = IsInputTypeNonNullable(field, field.Type);
+ }
+ else
+ {
+ isGetterNonNullable = isSetterNonNullable = false;
+ }
+ }
+
+ public static void ResolveNullabilityAnnotations(this IPropertySymbol property, out bool isGetterNonNullable, out bool isSetterNonNullable)
+ {
+ if (property.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not its instantiation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ property = property.OriginalDefinition;
+
+ isGetterNonNullable = property.GetMethod != null && IsOutputTypeNonNullable(property, property.Type);
+ isSetterNonNullable = property.SetMethod != null && IsInputTypeNonNullable(property, property.Type);
+ }
+ else
+ {
+ isGetterNonNullable = isSetterNonNullable = false;
+ }
+ }
+
+ public static bool IsNullable(this IParameterSymbol parameter)
+ {
+ if (parameter.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not instation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ parameter = parameter.OriginalDefinition;
+ return !IsInputTypeNonNullable(parameter, parameter.Type);
+ }
+
+ return false;
+ }
+
+ private static bool IsOutputTypeNonNullable(this ISymbol symbol, ITypeSymbol returnType)
+ {
+ if (symbol.HasCodeAnalysisAttribute("MaybeNullAttribute"))
+ {
+ return false;
+ }
+
+ if (symbol.HasCodeAnalysisAttribute("NotNullAttribute"))
+ {
+ return true;
+ }
+
+ if (returnType is ITypeParameterSymbol { HasNotNullConstraint: false })
+ {
+ return false;
+ }
+
+ return returnType.NullableAnnotation is NullableAnnotation.NotAnnotated;
+ }
+
+ private static bool IsInputTypeNonNullable(this ISymbol symbol, ITypeSymbol inputType)
+ {
+ Debug.Assert(inputType.IsNullableType());
+
+ if (symbol.HasCodeAnalysisAttribute("AllowNullAttribute"))
+ {
+ return false;
+ }
+
+ if (symbol.HasCodeAnalysisAttribute("DisallowNullAttribute"))
+ {
+ return true;
+ }
+
+ if (inputType is ITypeParameterSymbol { HasNotNullConstraint: false })
+ {
+ return false;
+ }
+
+ return inputType.NullableAnnotation is NullableAnnotation.NotAnnotated;
+ }
+
+ private static bool HasCodeAnalysisAttribute(this ISymbol symbol, string attributeName)
+ {
+ return symbol.GetAttributes().Any(attr =>
+ attr.AttributeClass?.Name == attributeName &&
+ attr.AttributeClass.ContainingNamespace.ToDisplayString() == "System.Diagnostics.CodeAnalysis");
+ }
  }
 }

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

@@ -30,6 +30,9 @@ private static class ExceptionMessages
 
  public const string InvalidSerializablePropertyConfiguration =
  "Invalid serializable-property configuration specified for type '{0}'. For more information, see 'JsonSourceGenerationMode.Serialization'.";
+
+ public const string PropertyGetterDisallowNull =
+ "The property or field '{0}' on type '{1}' doesn't allow getting null values. Consider updating its nullability annotation.";
  };
  }
  }

src/libraries/System.Private.CoreLib/src/System/Reflection/NullabilityInfo.cs

@@ -8,7 +8,12 @@ namespace System.Reflection
  /// <summary>
  /// A class that represents nullability info
  /// </summary>
- public sealed class NullabilityInfo
+#if NET
+ public
+#else
+ internal
+#endif
+ sealed class NullabilityInfo
  {
  internal NullabilityInfo(Type type, NullabilityState readState, NullabilityState writeState,
  NullabilityInfo? elementType, NullabilityInfo[] typeArguments)
@@ -46,7 +51,12 @@ internal NullabilityInfo(Type type, NullabilityState readState, NullabilityState
  /// <summary>
  /// An enum that represents nullability state
  /// </summary>
- public enum NullabilityState
+#if NET
+ public
+#else
+ internal
+#endif
+ enum NullabilityState
  {
  /// <summary>
  /// Nullability context not enabled (oblivious)

src/libraries/System.Private.CoreLib/src/System/Reflection/NullabilityInfoContext.cs

@@ -11,7 +11,12 @@ namespace System.Reflection
  /// Provides APIs for populating nullability information/context from reflection members:
  /// <see cref="ParameterInfo"/>, <see cref="FieldInfo"/>, <see cref="PropertyInfo"/> and <see cref="EventInfo"/>.
  /// </summary>
- public sealed class NullabilityInfoContext
+#if NET
+ public
+#else
+ internal
+#endif
+ sealed class NullabilityInfoContext
  {
  private const string CompilerServicesNameSpace = "System.Runtime.CompilerServices";
  private readonly Dictionary<Module, NotAnnotatedStatus> _publicOnlyModules = new();
@@ -65,7 +70,11 @@ private enum NotAnnotatedStatus
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(ParameterInfo parameterInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(parameterInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(parameterInfo, nameof(parameterInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -190,7 +199,11 @@ private static void CheckNullabilityAttributes(NullabilityInfo nullability, ILis
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(PropertyInfo propertyInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(propertyInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(propertyInfo, nameof(propertyInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -212,7 +225,9 @@ public NullabilityInfo Create(PropertyInfo propertyInfo)
 
  if (setter != null)
  {
- CheckNullabilityAttributes(nullability, setter.GetParametersAsSpan()[^1].GetCustomAttributesData());
+ ReadOnlySpan<ParameterInfo> parameters = setter.GetParametersAsSpan();
+ ParameterInfo parameter = parameters[parameters.Length - 1];
+ CheckNullabilityAttributes(nullability, parameter.GetCustomAttributesData());
  }
  else
  {
@@ -243,7 +258,11 @@ private bool IsPrivateOrInternalMethodAndAnnotationDisabled(MethodBase method)
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(EventInfo eventInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(eventInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(eventInfo, nameof(eventInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -260,7 +279,11 @@ public NullabilityInfo Create(EventInfo eventInfo)
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(FieldInfo fieldInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(fieldInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(fieldInfo, nameof(fieldInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -497,7 +520,11 @@ private bool TryUpdateGenericParameterNullability(NullabilityInfo nullability, T
  Debug.Assert(genericParameter.IsGenericParameter);
 
  if (reflectedType is not null
+#if NET
  && !genericParameter.IsGenericMethodParameter
+#else
+ && !genericParameter.IsGenericMethodParameter()
+#endif
  && TryUpdateGenericTypeParameterNullabilityFromReflectedType(nullability, genericParameter, reflectedType, reflectedType))
  {
  return true;
@@ -528,7 +555,12 @@ private bool TryUpdateGenericParameterNullability(NullabilityInfo nullability, T
 
  private bool TryUpdateGenericTypeParameterNullabilityFromReflectedType(NullabilityInfo nullability, Type genericParameter, Type context, Type reflectedType)
  {
- Debug.Assert(genericParameter.IsGenericParameter && !genericParameter.IsGenericMethodParameter);
+ Debug.Assert(genericParameter.IsGenericParameter &&
+#if NET
+ !genericParameter.IsGenericMethodParameter);
+#else
+ !genericParameter.IsGenericMethodParameter());
+#endif
 
  Type contextTypeDefinition = context.IsGenericType && !context.IsGenericTypeDefinition ? context.GetGenericTypeDefinition() : context;
  if (genericParameter.DeclaringType == contextTypeDefinition)
@@ -666,4 +698,54 @@ public bool ParseNullableState(int index, ref NullabilityState state)
  }
  }
  }
+
+#if !NET
+ internal static class NetstandardHelpers
+ {
+ public static void ThrowIfNull(object? argument, string paramName)
+ {
+ if (argument is null)
+ {
+ Throw(paramName);
+ static void Throw(string paramName) => throw new ArgumentNullException(paramName);
+ }
+ }
+
+ [Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern",
+ Justification = "This is finding the MemberInfo with the same MetadataToken as specified MemberInfo. If the specified MemberInfo " +
+ "exists and wasn't trimmed, then the current Type's MemberInfo couldn't have been trimmed.")]
+ public static MemberInfo GetMemberWithSameMetadataDefinitionAs(this Type type, MemberInfo member)
+ {
+ ThrowIfNull(member, nameof(member));
+
+ const BindingFlags all = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance;
+ foreach (MemberInfo myMemberInfo in type.GetMembers(all))
+ {
+ if (myMemberInfo.HasSameMetadataDefinitionAs(member))
+ {
+ return myMemberInfo;
+ }
+ }
+
+ throw new MissingMemberException(type.FullName, member.Name);
+ }
+
+ private static bool HasSameMetadataDefinitionAs(this MemberInfo info, MemberInfo other)
+ {
+ if (info.MetadataToken != other.MetadataToken)
+ return false;
+
+ if (!info.Module.Equals(other.Module))
+ return false;
+
+ return true;
+ }
+
+ public static bool IsGenericMethodParameter(this Type type)
+ => type.IsGenericParameter && type.DeclaringMethod is not null;
+
+ public static ReadOnlySpan<ParameterInfo> GetParametersAsSpan(this MethodBase metaMethod)
+ => metaMethod.GetParameters();
+ }
+#endif
 }

src/libraries/System.Text.Json/Common/JsonSourceGenerationOptionsAttribute.cs

@@ -115,6 +115,11 @@ public JsonSourceGenerationOptionsAttribute(JsonSerializerDefaults defaults)
  /// </summary>
  public JsonCommentHandling ReadCommentHandling { get; set; }
 
+ /// <summary>
+ /// Specifies the default value of <see cref="JsonSerializerOptions.RespectNullableAnnotations"/> when set.
+ /// </summary>
+ public bool RespectNullableAnnotations { get; set; }
+
  /// <summary>
  /// Specifies the default value of <see cref="JsonSerializerOptions.UnknownTypeHandling"/> when set.
  /// </summary>

src/libraries/System.Text.Json/gen/Helpers/RoslynExtensions.cs

@@ -50,6 +50,12 @@ public static ITypeSymbol EraseCompileTimeMetadata(this Compilation compilation,
  type = type.WithNullableAnnotation(NullableAnnotation.None);
  }
 
+ if (type is IArrayTypeSymbol arrayType)
+ {
+ ITypeSymbol elementType = compilation.EraseCompileTimeMetadata(arrayType.ElementType);
+ return compilation.CreateArrayTypeSymbol(elementType, arrayType.Rank);
+ }
+
  if (type is INamedTypeSymbol namedType)
  {
  if (namedType.IsTupleType)
@@ -189,6 +195,9 @@ SpecialType.System_Byte or SpecialType.System_UInt16 or SpecialType.System_UInt3
  SpecialType.System_Single or SpecialType.System_Double or SpecialType.System_Decimal;
  }
 
+ public static bool IsNullableType(this ITypeSymbol type)
+ => !type.IsValueType || type.OriginalDefinition.SpecialType is SpecialType.System_Nullable_T;
+
  public static bool IsNullableValueType(this ITypeSymbol type, [NotNullWhen(true)] out ITypeSymbol? elementType)
  {
  if (type.IsValueType && type is INamedTypeSymbol { OriginalDefinition.SpecialType: SpecialType.System_Nullable_T })
@@ -269,5 +278,107 @@ public static string GetTypeKindKeyword(this TypeDeclarationSyntax typeDeclarati
  return null;
  }
  }
+
+ public static void ResolveNullabilityAnnotations(this IFieldSymbol field, out bool isGetterNonNullable, out bool isSetterNonNullable)
+ {
+ if (field.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not its instantiation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ field = field.OriginalDefinition;
+
+ isGetterNonNullable = IsOutputTypeNonNullable(field, field.Type);
+ isSetterNonNullable = IsInputTypeNonNullable(field, field.Type);
+ }
+ else
+ {
+ isGetterNonNullable = isSetterNonNullable = false;
+ }
+ }
+
+ public static void ResolveNullabilityAnnotations(this IPropertySymbol property, out bool isGetterNonNullable, out bool isSetterNonNullable)
+ {
+ if (property.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not its instantiation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ property = property.OriginalDefinition;
+
+ isGetterNonNullable = property.GetMethod != null && IsOutputTypeNonNullable(property, property.Type);
+ isSetterNonNullable = property.SetMethod != null && IsInputTypeNonNullable(property, property.Type);
+ }
+ else
+ {
+ isGetterNonNullable = isSetterNonNullable = false;
+ }
+ }
+
+ public static bool IsNullable(this IParameterSymbol parameter)
+ {
+ if (parameter.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not instation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ parameter = parameter.OriginalDefinition;
+ return !IsInputTypeNonNullable(parameter, parameter.Type);
+ }
+
+ return false;
+ }
+
+ private static bool IsOutputTypeNonNullable(this ISymbol symbol, ITypeSymbol returnType)
+ {
+ if (symbol.HasCodeAnalysisAttribute("MaybeNullAttribute"))
+ {
+ return false;
+ }
+
+ if (symbol.HasCodeAnalysisAttribute("NotNullAttribute"))
+ {
+ return true;
+ }
+
+ if (returnType is ITypeParameterSymbol { HasNotNullConstraint: false })
+ {
+ return false;
+ }
+
+ return returnType.NullableAnnotation is NullableAnnotation.NotAnnotated;
+ }
+
+ private static bool IsInputTypeNonNullable(this ISymbol symbol, ITypeSymbol inputType)
+ {
+ Debug.Assert(inputType.IsNullableType());
+
+ if (symbol.HasCodeAnalysisAttribute("AllowNullAttribute"))
+ {
+ return false;
+ }
+
+ if (symbol.HasCodeAnalysisAttribute("DisallowNullAttribute"))
+ {
+ return true;
+ }
+
+ if (inputType is ITypeParameterSymbol { HasNotNullConstraint: false })
+ {
+ return false;
+ }
+
+ return inputType.NullableAnnotation is NullableAnnotation.NotAnnotated;
+ }
+
+ private static bool HasCodeAnalysisAttribute(this ISymbol symbol, string attributeName)
+ {
+ return symbol.GetAttributes().Any(attr =>
+ attr.AttributeClass?.Name == attributeName &&
+ attr.AttributeClass.ContainingNamespace.ToDisplayString() == "System.Diagnostics.CodeAnalysis");
+ }
  }
 }

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

@@ -30,6 +30,9 @@ private static class ExceptionMessages
 
  public const string InvalidSerializablePropertyConfiguration =
  "Invalid serializable-property configuration specified for type '{0}'. For more information, see 'JsonSourceGenerationMode.Serialization'.";
+
+ public const string PropertyGetterDisallowNull =
+ "The property or field '{0}' on type '{1}' doesn't allow getting null values. Consider updating its nullability annotation.";
  };
  }
  }

src/libraries/System.Private.CoreLib/src/System/Reflection/NullabilityInfo.cs

@@ -8,7 +8,12 @@ namespace System.Reflection
  /// <summary>
  /// A class that represents nullability info
  /// </summary>
- public sealed class NullabilityInfo
+#if NET
+ public
+#else
+ internal
+#endif
+ sealed class NullabilityInfo
  {
  internal NullabilityInfo(Type type, NullabilityState readState, NullabilityState writeState,
  NullabilityInfo? elementType, NullabilityInfo[] typeArguments)
@@ -46,7 +51,12 @@ internal NullabilityInfo(Type type, NullabilityState readState, NullabilityState
  /// <summary>
  /// An enum that represents nullability state
  /// </summary>
- public enum NullabilityState
+#if NET
+ public
+#else
+ internal
+#endif
+ enum NullabilityState
  {
  /// <summary>
  /// Nullability context not enabled (oblivious)

src/libraries/System.Private.CoreLib/src/System/Reflection/NullabilityInfoContext.cs

@@ -11,7 +11,12 @@ namespace System.Reflection
  /// Provides APIs for populating nullability information/context from reflection members:
  /// <see cref="ParameterInfo"/>, <see cref="FieldInfo"/>, <see cref="PropertyInfo"/> and <see cref="EventInfo"/>.
  /// </summary>
- public sealed class NullabilityInfoContext
+#if NET
+ public
+#else
+ internal
+#endif
+ sealed class NullabilityInfoContext
  {
  private const string CompilerServicesNameSpace = "System.Runtime.CompilerServices";
  private readonly Dictionary<Module, NotAnnotatedStatus> _publicOnlyModules = new();
@@ -65,7 +70,11 @@ private enum NotAnnotatedStatus
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(ParameterInfo parameterInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(parameterInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(parameterInfo, nameof(parameterInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -190,7 +199,11 @@ private static void CheckNullabilityAttributes(NullabilityInfo nullability, ILis
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(PropertyInfo propertyInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(propertyInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(propertyInfo, nameof(propertyInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -212,7 +225,9 @@ public NullabilityInfo Create(PropertyInfo propertyInfo)
 
  if (setter != null)
  {
- CheckNullabilityAttributes(nullability, setter.GetParametersAsSpan()[^1].GetCustomAttributesData());
+ ReadOnlySpan<ParameterInfo> parameters = setter.GetParametersAsSpan();
+ ParameterInfo parameter = parameters[parameters.Length - 1];
+ CheckNullabilityAttributes(nullability, parameter.GetCustomAttributesData());
  }
  else
  {
@@ -243,7 +258,11 @@ private bool IsPrivateOrInternalMethodAndAnnotationDisabled(MethodBase method)
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(EventInfo eventInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(eventInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(eventInfo, nameof(eventInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -260,7 +279,11 @@ public NullabilityInfo Create(EventInfo eventInfo)
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(FieldInfo fieldInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(fieldInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(fieldInfo, nameof(fieldInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -497,7 +520,11 @@ private bool TryUpdateGenericParameterNullability(NullabilityInfo nullability, T
  Debug.Assert(genericParameter.IsGenericParameter);
 
  if (reflectedType is not null
+#if NET
  && !genericParameter.IsGenericMethodParameter
+#else
+ && !genericParameter.IsGenericMethodParameter()
+#endif
  && TryUpdateGenericTypeParameterNullabilityFromReflectedType(nullability, genericParameter, reflectedType, reflectedType))
  {
  return true;
@@ -528,7 +555,12 @@ private bool TryUpdateGenericParameterNullability(NullabilityInfo nullability, T
 
  private bool TryUpdateGenericTypeParameterNullabilityFromReflectedType(NullabilityInfo nullability, Type genericParameter, Type context, Type reflectedType)
  {
- Debug.Assert(genericParameter.IsGenericParameter && !genericParameter.IsGenericMethodParameter);
+ Debug.Assert(genericParameter.IsGenericParameter &&
+#if NET
+ !genericParameter.IsGenericMethodParameter);
+#else
+ !genericParameter.IsGenericMethodParameter());
+#endif
 
  Type contextTypeDefinition = context.IsGenericType && !context.IsGenericTypeDefinition ? context.GetGenericTypeDefinition() : context;
  if (genericParameter.DeclaringType == contextTypeDefinition)
@@ -666,4 +698,54 @@ public bool ParseNullableState(int index, ref NullabilityState state)
  }
  }
  }
+
+#if !NET
+ internal static class NetstandardHelpers
+ {
+ public static void ThrowIfNull(object? argument, string paramName)
+ {
+ if (argument is null)
+ {
+ Throw(paramName);
+ static void Throw(string paramName) => throw new ArgumentNullException(paramName);
+ }
+ }
+
+ [Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern",
+ Justification = "This is finding the MemberInfo with the same MetadataToken as specified MemberInfo. If the specified MemberInfo " +
+ "exists and wasn't trimmed, then the current Type's MemberInfo couldn't have been trimmed.")]
+ public static MemberInfo GetMemberWithSameMetadataDefinitionAs(this Type type, MemberInfo member)
+ {
+ ThrowIfNull(member, nameof(member));
+
+ const BindingFlags all = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance;
+ foreach (MemberInfo myMemberInfo in type.GetMembers(all))
+ {
+ if (myMemberInfo.HasSameMetadataDefinitionAs(member))
+ {
+ return myMemberInfo;
+ }
+ }
+
+ throw new MissingMemberException(type.FullName, member.Name);
+ }
+
+ private static bool HasSameMetadataDefinitionAs(this MemberInfo info, MemberInfo other)
+ {
+ if (info.MetadataToken != other.MetadataToken)
+ return false;
+
+ if (!info.Module.Equals(other.Module))
+ return false;
+
+ return true;
+ }
+
+ public static bool IsGenericMethodParameter(this Type type)
+ => type.IsGenericParameter && type.DeclaringMethod is not null;
+
+ public static ReadOnlySpan<ParameterInfo> GetParametersAsSpan(this MethodBase metaMethod)
+ => metaMethod.GetParameters();
+ }
+#endif
 }

src/libraries/System.Text.Json/Common/JsonSourceGenerationOptionsAttribute.cs

@@ -115,6 +115,11 @@ public JsonSourceGenerationOptionsAttribute(JsonSerializerDefaults defaults)
  /// </summary>
  public JsonCommentHandling ReadCommentHandling { get; set; }
 
+ /// <summary>
+ /// Specifies the default value of <see cref="JsonSerializerOptions.RespectNullableAnnotations"/> when set.
+ /// </summary>
+ public bool RespectNullableAnnotations { get; set; }
+
  /// <summary>
  /// Specifies the default value of <see cref="JsonSerializerOptions.UnknownTypeHandling"/> when set.
  /// </summary>

src/libraries/System.Text.Json/gen/Helpers/RoslynExtensions.cs

@@ -50,6 +50,12 @@ public static ITypeSymbol EraseCompileTimeMetadata(this Compilation compilation,
  type = type.WithNullableAnnotation(NullableAnnotation.None);
  }
 
+ if (type is IArrayTypeSymbol arrayType)
+ {
+ ITypeSymbol elementType = compilation.EraseCompileTimeMetadata(arrayType.ElementType);
+ return compilation.CreateArrayTypeSymbol(elementType, arrayType.Rank);
+ }
+
  if (type is INamedTypeSymbol namedType)
  {
  if (namedType.IsTupleType)
@@ -189,6 +195,9 @@ SpecialType.System_Byte or SpecialType.System_UInt16 or SpecialType.System_UInt3
  SpecialType.System_Single or SpecialType.System_Double or SpecialType.System_Decimal;
  }
 
+ public static bool IsNullableType(this ITypeSymbol type)
+ => !type.IsValueType || type.OriginalDefinition.SpecialType is SpecialType.System_Nullable_T;
+
  public static bool IsNullableValueType(this ITypeSymbol type, [NotNullWhen(true)] out ITypeSymbol? elementType)
  {
  if (type.IsValueType && type is INamedTypeSymbol { OriginalDefinition.SpecialType: SpecialType.System_Nullable_T })
@@ -269,5 +278,107 @@ public static string GetTypeKindKeyword(this TypeDeclarationSyntax typeDeclarati
  return null;
  }
  }
+
+ public static void ResolveNullabilityAnnotations(this IFieldSymbol field, out bool isGetterNonNullable, out bool isSetterNonNullable)
+ {
+ if (field.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not its instantiation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ field = field.OriginalDefinition;
+
+ isGetterNonNullable = IsOutputTypeNonNullable(field, field.Type);
+ isSetterNonNullable = IsInputTypeNonNullable(field, field.Type);
+ }
+ else
+ {
+ isGetterNonNullable = isSetterNonNullable = false;
+ }
+ }
+
+ public static void ResolveNullabilityAnnotations(this IPropertySymbol property, out bool isGetterNonNullable, out bool isSetterNonNullable)
+ {
+ if (property.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not its instantiation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ property = property.OriginalDefinition;
+
+ isGetterNonNullable = property.GetMethod != null && IsOutputTypeNonNullable(property, property.Type);
+ isSetterNonNullable = property.SetMethod != null && IsInputTypeNonNullable(property, property.Type);
+ }
+ else
+ {
+ isGetterNonNullable = isSetterNonNullable = false;
+ }
+ }
+
+ public static bool IsNullable(this IParameterSymbol parameter)
+ {
+ if (parameter.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not instation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ parameter = parameter.OriginalDefinition;
+ return !IsInputTypeNonNullable(parameter, parameter.Type);
+ }
+
+ return false;
+ }
+
+ private static bool IsOutputTypeNonNullable(this ISymbol symbol, ITypeSymbol returnType)
+ {
+ if (symbol.HasCodeAnalysisAttribute("MaybeNullAttribute"))
+ {
+ return false;
+ }
+
+ if (symbol.HasCodeAnalysisAttribute("NotNullAttribute"))
+ {
+ return true;
+ }
+
+ if (returnType is ITypeParameterSymbol { HasNotNullConstraint: false })
+ {
+ return false;
+ }
+
+ return returnType.NullableAnnotation is NullableAnnotation.NotAnnotated;
+ }
+
+ private static bool IsInputTypeNonNullable(this ISymbol symbol, ITypeSymbol inputType)
+ {
+ Debug.Assert(inputType.IsNullableType());
+
+ if (symbol.HasCodeAnalysisAttribute("AllowNullAttribute"))
+ {
+ return false;
+ }
+
+ if (symbol.HasCodeAnalysisAttribute("DisallowNullAttribute"))
+ {
+ return true;
+ }
+
+ if (inputType is ITypeParameterSymbol { HasNotNullConstraint: false })
+ {
+ return false;
+ }
+
+ return inputType.NullableAnnotation is NullableAnnotation.NotAnnotated;
+ }
+
+ private static bool HasCodeAnalysisAttribute(this ISymbol symbol, string attributeName)
+ {
+ return symbol.GetAttributes().Any(attr =>
+ attr.AttributeClass?.Name == attributeName &&
+ attr.AttributeClass.ContainingNamespace.ToDisplayString() == "System.Diagnostics.CodeAnalysis");
+ }
  }
 }

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

@@ -30,6 +30,9 @@ private static class ExceptionMessages
 
  public const string InvalidSerializablePropertyConfiguration =
  "Invalid serializable-property configuration specified for type '{0}'. For more information, see 'JsonSourceGenerationMode.Serialization'.";
+
+ public const string PropertyGetterDisallowNull =
+ "The property or field '{0}' on type '{1}' doesn't allow getting null values. Consider updating its nullability annotation.";
  };
  }
  }

src/libraries/System.Private.CoreLib/src/System/Reflection/NullabilityInfo.cs

@@ -8,7 +8,12 @@ namespace System.Reflection
  /// <summary>
  /// A class that represents nullability info
  /// </summary>
- public sealed class NullabilityInfo
+#if NET
+ public
+#else
+ internal
+#endif
+ sealed class NullabilityInfo
  {
  internal NullabilityInfo(Type type, NullabilityState readState, NullabilityState writeState,
  NullabilityInfo? elementType, NullabilityInfo[] typeArguments)
@@ -46,7 +51,12 @@ internal NullabilityInfo(Type type, NullabilityState readState, NullabilityState
  /// <summary>
  /// An enum that represents nullability state
  /// </summary>
- public enum NullabilityState
+#if NET
+ public
+#else
+ internal
+#endif
+ enum NullabilityState
  {
  /// <summary>
  /// Nullability context not enabled (oblivious)

src/libraries/System.Private.CoreLib/src/System/Reflection/NullabilityInfoContext.cs

@@ -11,7 +11,12 @@ namespace System.Reflection
  /// Provides APIs for populating nullability information/context from reflection members:
  /// <see cref="ParameterInfo"/>, <see cref="FieldInfo"/>, <see cref="PropertyInfo"/> and <see cref="EventInfo"/>.
  /// </summary>
- public sealed class NullabilityInfoContext
+#if NET
+ public
+#else
+ internal
+#endif
+ sealed class NullabilityInfoContext
  {
  private const string CompilerServicesNameSpace = "System.Runtime.CompilerServices";
  private readonly Dictionary<Module, NotAnnotatedStatus> _publicOnlyModules = new();
@@ -65,7 +70,11 @@ private enum NotAnnotatedStatus
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(ParameterInfo parameterInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(parameterInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(parameterInfo, nameof(parameterInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -190,7 +199,11 @@ private static void CheckNullabilityAttributes(NullabilityInfo nullability, ILis
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(PropertyInfo propertyInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(propertyInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(propertyInfo, nameof(propertyInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -212,7 +225,9 @@ public NullabilityInfo Create(PropertyInfo propertyInfo)
 
  if (setter != null)
  {
- CheckNullabilityAttributes(nullability, setter.GetParametersAsSpan()[^1].GetCustomAttributesData());
+ ReadOnlySpan<ParameterInfo> parameters = setter.GetParametersAsSpan();
+ ParameterInfo parameter = parameters[parameters.Length - 1];
+ CheckNullabilityAttributes(nullability, parameter.GetCustomAttributesData());
  }
  else
  {
@@ -243,7 +258,11 @@ private bool IsPrivateOrInternalMethodAndAnnotationDisabled(MethodBase method)
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(EventInfo eventInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(eventInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(eventInfo, nameof(eventInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -260,7 +279,11 @@ public NullabilityInfo Create(EventInfo eventInfo)
  /// <returns><see cref="NullabilityInfo" /></returns>
  public NullabilityInfo Create(FieldInfo fieldInfo)
  {
+#if NET
  ArgumentNullException.ThrowIfNull(fieldInfo);
+#else
+ NetstandardHelpers.ThrowIfNull(fieldInfo, nameof(fieldInfo));
+#endif
 
  EnsureIsSupported();
 
@@ -497,7 +520,11 @@ private bool TryUpdateGenericParameterNullability(NullabilityInfo nullability, T
  Debug.Assert(genericParameter.IsGenericParameter);
 
  if (reflectedType is not null
+#if NET
  && !genericParameter.IsGenericMethodParameter
+#else
+ && !genericParameter.IsGenericMethodParameter()
+#endif
  && TryUpdateGenericTypeParameterNullabilityFromReflectedType(nullability, genericParameter, reflectedType, reflectedType))
  {
  return true;
@@ -528,7 +555,12 @@ private bool TryUpdateGenericParameterNullability(NullabilityInfo nullability, T
 
  private bool TryUpdateGenericTypeParameterNullabilityFromReflectedType(NullabilityInfo nullability, Type genericParameter, Type context, Type reflectedType)
  {
- Debug.Assert(genericParameter.IsGenericParameter && !genericParameter.IsGenericMethodParameter);
+ Debug.Assert(genericParameter.IsGenericParameter &&
+#if NET
+ !genericParameter.IsGenericMethodParameter);
+#else
+ !genericParameter.IsGenericMethodParameter());
+#endif
 
  Type contextTypeDefinition = context.IsGenericType && !context.IsGenericTypeDefinition ? context.GetGenericTypeDefinition() : context;
  if (genericParameter.DeclaringType == contextTypeDefinition)
@@ -666,4 +698,54 @@ public bool ParseNullableState(int index, ref NullabilityState state)
  }
  }
  }
+
+#if !NET
+ internal static class NetstandardHelpers
+ {
+ public static void ThrowIfNull(object? argument, string paramName)
+ {
+ if (argument is null)
+ {
+ Throw(paramName);
+ static void Throw(string paramName) => throw new ArgumentNullException(paramName);
+ }
+ }
+
+ [Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern",
+ Justification = "This is finding the MemberInfo with the same MetadataToken as specified MemberInfo. If the specified MemberInfo " +
+ "exists and wasn't trimmed, then the current Type's MemberInfo couldn't have been trimmed.")]
+ public static MemberInfo GetMemberWithSameMetadataDefinitionAs(this Type type, MemberInfo member)
+ {
+ ThrowIfNull(member, nameof(member));
+
+ const BindingFlags all = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance;
+ foreach (MemberInfo myMemberInfo in type.GetMembers(all))
+ {
+ if (myMemberInfo.HasSameMetadataDefinitionAs(member))
+ {
+ return myMemberInfo;
+ }
+ }
+
+ throw new MissingMemberException(type.FullName, member.Name);
+ }
+
+ private static bool HasSameMetadataDefinitionAs(this MemberInfo info, MemberInfo other)
+ {
+ if (info.MetadataToken != other.MetadataToken)
+ return false;
+
+ if (!info.Module.Equals(other.Module))
+ return false;
+
+ return true;
+ }
+
+ public static bool IsGenericMethodParameter(this Type type)
+ => type.IsGenericParameter && type.DeclaringMethod is not null;
+
+ public static ReadOnlySpan<ParameterInfo> GetParametersAsSpan(this MethodBase metaMethod)
+ => metaMethod.GetParameters();
+ }
+#endif
 }

src/libraries/System.Text.Json/Common/JsonSourceGenerationOptionsAttribute.cs

@@ -115,6 +115,11 @@ public JsonSourceGenerationOptionsAttribute(JsonSerializerDefaults defaults)
  /// </summary>
  public JsonCommentHandling ReadCommentHandling { get; set; }
 
+ /// <summary>
+ /// Specifies the default value of <see cref="JsonSerializerOptions.RespectNullableAnnotations"/> when set.
+ /// </summary>
+ public bool RespectNullableAnnotations { get; set; }
+
  /// <summary>
  /// Specifies the default value of <see cref="JsonSerializerOptions.UnknownTypeHandling"/> when set.
  /// </summary>

src/libraries/System.Text.Json/gen/Helpers/RoslynExtensions.cs

@@ -50,6 +50,12 @@ public static ITypeSymbol EraseCompileTimeMetadata(this Compilation compilation,
  type = type.WithNullableAnnotation(NullableAnnotation.None);
  }
 
+ if (type is IArrayTypeSymbol arrayType)
+ {
+ ITypeSymbol elementType = compilation.EraseCompileTimeMetadata(arrayType.ElementType);
+ return compilation.CreateArrayTypeSymbol(elementType, arrayType.Rank);
+ }
+
  if (type is INamedTypeSymbol namedType)
  {
  if (namedType.IsTupleType)
@@ -189,6 +195,9 @@ SpecialType.System_Byte or SpecialType.System_UInt16 or SpecialType.System_UInt3
  SpecialType.System_Single or SpecialType.System_Double or SpecialType.System_Decimal;
  }
 
+ public static bool IsNullableType(this ITypeSymbol type)
+ => !type.IsValueType || type.OriginalDefinition.SpecialType is SpecialType.System_Nullable_T;
+
  public static bool IsNullableValueType(this ITypeSymbol type, [NotNullWhen(true)] out ITypeSymbol? elementType)
  {
  if (type.IsValueType && type is INamedTypeSymbol { OriginalDefinition.SpecialType: SpecialType.System_Nullable_T })
@@ -269,5 +278,107 @@ public static string GetTypeKindKeyword(this TypeDeclarationSyntax typeDeclarati
  return null;
  }
  }
+
+ public static void ResolveNullabilityAnnotations(this IFieldSymbol field, out bool isGetterNonNullable, out bool isSetterNonNullable)
+ {
+ if (field.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not its instantiation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ field = field.OriginalDefinition;
+
+ isGetterNonNullable = IsOutputTypeNonNullable(field, field.Type);
+ isSetterNonNullable = IsInputTypeNonNullable(field, field.Type);
+ }
+ else
+ {
+ isGetterNonNullable = isSetterNonNullable = false;
+ }
+ }
+
+ public static void ResolveNullabilityAnnotations(this IPropertySymbol property, out bool isGetterNonNullable, out bool isSetterNonNullable)
+ {
+ if (property.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not its instantiation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ property = property.OriginalDefinition;
+
+ isGetterNonNullable = property.GetMethod != null && IsOutputTypeNonNullable(property, property.Type);
+ isSetterNonNullable = property.SetMethod != null && IsInputTypeNonNullable(property, property.Type);
+ }
+ else
+ {
+ isGetterNonNullable = isSetterNonNullable = false;
+ }
+ }
+
+ public static bool IsNullable(this IParameterSymbol parameter)
+ {
+ if (parameter.Type.IsNullableType())
+ {
+ // Because System.Text.Json cannot distinguish between nullable and non-nullable type parameters,
+ // (e.g. the same metadata is being used for both KeyValuePair<string, string?> and KeyValuePair<string, string>),
+ // we derive nullability annotations from the original definition of the field and not instation.
+ // This preserves compatibility with the capabilities of the reflection-based NullabilityInfo reader.
+ parameter = parameter.OriginalDefinition;
+ return !IsInputTypeNonNullable(parameter, parameter.Type);
+ }
+
+ return false;
+ }
+
+ private static bool IsOutputTypeNonNullable(this ISymbol symbol, ITypeSymbol returnType)
+ {
+ if (symbol.HasCodeAnalysisAttribute("MaybeNullAttribute"))
+ {
+ return false;
+ }
+
+ if (symbol.HasCodeAnalysisAttribute("NotNullAttribute"))
+ {
+ return true;
+ }
+
+ if (returnType is ITypeParameterSymbol { HasNotNullConstraint: false })
+ {
+ return false;
+ }
+
+ return returnType.NullableAnnotation is NullableAnnotation.NotAnnotated;
+ }
+
+ private static bool IsInputTypeNonNullable(this ISymbol symbol, ITypeSymbol inputType)
+ {
+ Debug.Assert(inputType.IsNullableType());
+
+ if (symbol.HasCodeAnalysisAttribute("AllowNullAttribute"))
+ {
+ return false;
+ }
+
+ if (symbol.HasCodeAnalysisAttribute("DisallowNullAttribute"))
+ {
+ return true;
+ }
+
+ if (inputType is ITypeParameterSymbol { HasNotNullConstraint: false })
+ {
+ return false;
+ }
+
+ return inputType.NullableAnnotation is NullableAnnotation.NotAnnotated;
+ }
+
+ private static bool HasCodeAnalysisAttribute(this ISymbol symbol, string attributeName)
+ {
+ return symbol.GetAttributes().Any(attr =>
+ attr.AttributeClass?.Name == attributeName &&
+ attr.AttributeClass.ContainingNamespace.ToDisplayString() == "System.Diagnostics.CodeAnalysis");
+ }
  }
 }

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

@@ -30,6 +30,9 @@ private static class ExceptionMessages
 
  public const string InvalidSerializablePropertyConfiguration =
  "Invalid serializable-property configuration specified for type '{0}'. For more information, see 'JsonSourceGenerationMode.Serialization'.";
+
+ public const string PropertyGetterDisallowNull =
+ "The property or field '{0}' on type '{1}' doesn't allow getting null values. Consider updating its nullability annotation.";
  };
  }
  }