Make JSON support required properties

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

@@ -659,4 +659,16 @@
   <data name="JsonPolymorphismOptionsAssociatedWithDifferentJsonTypeInfo" xml:space="preserve">
     <value>Parameter already associated with a different JsonTypeInfo instance.</value>
   </data>
-</root>
+  <data name="JsonPropertyRequiredAndNotDeserializable" xml:space="preserve">
+    <value>JsonPropertyInfo with name '{0}' for type '{1}' is required but is not deserializable.</value>
+  </data>
+  <data name="JsonPropertyRequiredAndExtensionData" xml:space="preserve">
+    <value>JsonPropertyInfo with name '{0}' for type '{1}' cannot be required and be an extension data property.</value>
+  </data>
+  <data name="JsonRequiredPropertiesMissing" xml:space="preserve">
+    <value>Type '{0}' contains required properties which were not set during deserialization: {1}</value>
+  </data>
+  <data name="JsonPropertyRequiredAndIgnoreNullValues" xml:space="preserve">
+    <value>Required JSON properties cannot be used in conjunction with JsonSerializerOptions.IgnoreNullValues.</value>
+  </data>
+</root>

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

@@ -39,6 +39,7 @@ internal override bool OnTryRead(ref Utf8JsonReader reader, Type typeToConvert,
                 obj = jsonTypeInfo.CreateObject()!;
 
                 jsonTypeInfo.OnDeserializing?.Invoke(obj);
+                state.Current.InitializeRequiredProperties(jsonTypeInfo);
 
                 // Process all properties.
                 while (true)
@@ -143,6 +144,7 @@ internal override bool OnTryRead(ref Utf8JsonReader reader, Type typeToConvert,
 
                     state.Current.ReturnValue = obj;
                     state.Current.ObjectState = StackFrameObjectState.CreatedObject;
+                    state.Current.InitializeRequiredProperties(jsonTypeInfo);
                 }
                 else
                 {
@@ -250,6 +252,7 @@ internal override bool OnTryRead(ref Utf8JsonReader reader, Type typeToConvert,
             }
 
             jsonTypeInfo.OnDeserialized?.Invoke(obj);
+            state.Current.ValidateAllRequiredPropertiesAreRead(jsonTypeInfo);
 
             // Unbox
             Debug.Assert(obj != null);

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Large.cs

@@ -24,6 +24,9 @@ protected sealed override bool ReadAndCacheConstructorArgument(ref ReadStack sta
             if (success && !(arg == null && jsonParameterInfo.IgnoreNullTokensOnRead))
             {
                 ((object[])state.Current.CtorArgumentState!.Arguments)[jsonParameterInfo.ClrInfo.Position] = arg!;
+
+                // if this is required property IgnoreNullTokensOnRead will always be false because we don't allow for both to be true
+                state.Current.MarkRequiredPropertyAsRead(jsonParameterInfo.MatchingProperty);
             }
 
             return success;

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Small.cs

@@ -71,6 +71,11 @@ private static bool TryRead<TArg>(
                 ? (TArg?)info.DefaultValue! // Use default value specified on parameter, if any.
                 : value!;
 
+            if (success)
+            {
+                state.Current.MarkRequiredPropertyAsRead(jsonParameterInfo.MatchingProperty);
+            }
+
             return success;
         }
 

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

@@ -184,7 +184,15 @@ internal sealed override bool OnTryRead(ref Utf8JsonReader reader, Type typeToCo
 
                         if (dataExtKey == null)
                         {
-                            jsonPropertyInfo.SetExtensionDictionaryAsObject(obj, propValue);
+                            Debug.Assert(jsonPropertyInfo.Set != null);
+
+                            if (propValue is not null || !jsonPropertyInfo.IgnoreNullTokensOnRead || default(T) is not null)
+                            {
+                                jsonPropertyInfo.Set(obj, propValue);
+
+                                // if this is required property IgnoreNullTokensOnRead will always be false because we don't allow for both to be true
+                                state.Current.MarkRequiredPropertyAsRead(jsonPropertyInfo);
+                            }
                         }
                         else
                         {
@@ -211,6 +219,7 @@ internal sealed override bool OnTryRead(ref Utf8JsonReader reader, Type typeToCo
             }
 
             jsonTypeInfo.OnDeserialized?.Invoke(obj);
+            state.Current.ValidateAllRequiredPropertiesAreRead(jsonTypeInfo);
 
             // Unbox
             Debug.Assert(obj != null);
@@ -272,6 +281,7 @@ private void ReadConstructorArguments(ref ReadStack state, ref Utf8JsonReader re
                         continue;
                     }
 
+                    Debug.Assert(jsonParameterInfo.MatchingProperty != null);
                     ReadAndCacheConstructorArgument(ref state, ref reader, jsonParameterInfo);
 
                     state.Current.EndConstructorParameter();
@@ -532,6 +542,8 @@ private void BeginRead(ref ReadStack state, ref Utf8JsonReader reader, JsonSeria
                 ThrowHelper.ThrowInvalidOperationException_ConstructorParameterIncompleteBinding(TypeToConvert);
             }
 
+            state.Current.InitializeRequiredProperties(jsonTypeInfo);
+
             // Set current JsonPropertyInfo to null to avoid conflicts on push.
             state.Current.JsonPropertyInfo = null;
 

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Read.HandlePropertyName.cs

@@ -139,7 +139,8 @@ internal static void CreateExtensionDataProperty(
                 }
 
                 extensionData = createObjectForExtensionDataProp();
-                jsonPropertyInfo.SetExtensionDictionaryAsObject(obj, extensionData);
+                Debug.Assert(jsonPropertyInfo.Set != null);
+                jsonPropertyInfo.Set(obj, extensionData);
             }
 
             // We don't add the value to the dictionary here because we need to support the read-ahead functionality for Streams.

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

@@ -53,8 +53,11 @@ public JsonTypeInfo JsonTypeInfo
 
         public bool ShouldDeserialize { get; private set; }
 
+        public JsonPropertyInfo MatchingProperty { get; private set; } = null!;
+
         public virtual void Initialize(JsonParameterInfoValues parameterInfo, JsonPropertyInfo matchingProperty, JsonSerializerOptions options)
         {
+            MatchingProperty = matchingProperty;
             ClrInfo = parameterInfo;
             Options = options;
             ShouldDeserialize = true;

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

@@ -203,6 +203,18 @@ public bool IsExtensionData
 
         private bool _isExtensionDataProperty;
 
+        internal bool IsRequired
+        {
+            get => _isRequired;
+            set
+            {
+                VerifyMutable();
+                _isRequired = value;
+            }
+        }
+
+        private bool _isRequired;
+
         internal JsonPropertyInfo(Type declaringType, Type propertyType, JsonTypeInfo? declaringTypeInfo, JsonSerializerOptions options)
         {
             Debug.Assert(declaringTypeInfo is null || declaringTypeInfo.Type == declaringType);
@@ -279,6 +291,24 @@ internal void Configure()
                 DetermineIgnoreCondition();
                 DetermineSerializationCapabilities();
             }
+
+            if (IsRequired)
+            {
+                if (!CanDeserialize)
+                {
+                    ThrowHelper.ThrowInvalidOperationException_JsonPropertyRequiredAndNotDeserializable(this);
+                }
+
+                if (IsExtensionData)
+                {
+                    ThrowHelper.ThrowInvalidOperationException_JsonPropertyRequiredAndExtensionData(this);
+                }
+
+                if (IgnoreNullTokensOnRead)
+                {
+                    ThrowHelper.ThrowInvalidOperationException_JsonPropertyRequiredAndIgnoreNullValues();
+                }
+            }
         }
 
         private protected abstract void DetermineEffectiveConverter(JsonTypeInfo jsonTypeInfo);
@@ -760,8 +790,6 @@ internal JsonTypeInfo JsonTypeInfo
             }
         }
 
-        internal abstract void SetExtensionDictionaryAsObject(object obj, object? extensionDict);
-
         internal bool IsIgnored => _ignoreCondition == JsonIgnoreCondition.Always;
 
         /// <summary>
@@ -823,6 +851,27 @@ public JsonNumberHandling? NumberHandling
         /// </summary>
         internal abstract object? DefaultValue { get; }
 
+        /// <summary>
+        /// Property index on the list of JsonTypeInfo properties.
+        /// Can be used as a unique identifier for i.e. required properties.
+        /// It is set just before property is configured and does not change afterward.
+        /// </summary>
+        internal int Index
+        {
+            get
+            {
+                Debug.Assert(_isConfigured);
+                return _index;
+            }
+            set
+            {
+                Debug.Assert(!_isConfigured);
+                _index = value;
+            }
+        }
+
+        private int _index;
+
         [DebuggerBrowsable(DebuggerBrowsableState.Never)]
         private string DebuggerDisplay => $"PropertyType = {PropertyType}, Name = {Name}, DeclaringType = {DeclaringType}";
     }

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

@@ -342,6 +342,7 @@ internal override bool ReadJsonAndSetMember(object obj, ref ReadStack state, ref
                 }
 
                 success = true;
+                state.Current.MarkRequiredPropertyAsRead(this);
             }
             else if (TypedEffectiveConverter.CanUseDirectReadOrWrite && state.Current.NumberHandling == null)
             {
@@ -356,6 +357,7 @@ internal override bool ReadJsonAndSetMember(object obj, ref ReadStack state, ref
                 }
 
                 success = true;
+                state.Current.MarkRequiredPropertyAsRead(this);
             }
             else
             {
@@ -366,6 +368,7 @@ internal override bool ReadJsonAndSetMember(object obj, ref ReadStack state, ref
                     if (success)
                     {
                         Set!(obj, value!);
+                        state.Current.MarkRequiredPropertyAsRead(this);
                     }
                 }
             }
@@ -408,13 +411,6 @@ internal override bool ReadJsonAsObject(ref ReadStack state, ref Utf8JsonReader
             return success;
         }
 
-        internal override void SetExtensionDictionaryAsObject(object obj, object? extensionDict)
-        {
-            Debug.Assert(HasSetter);
-            T typedValue = (T)extensionDict!;
-            Set!(obj, typedValue);
-        }
-
         private protected override void ConfigureIgnoreCondition(JsonIgnoreCondition? ignoreCondition)
         {
             switch (ignoreCondition)

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

@@ -26,6 +26,11 @@ public abstract partial class JsonTypeInfo
 
         private JsonPropertyInfoList? _properties;
 
+        /// <summary>
+        /// Indices of required properties.
+        /// </summary>
+        internal int[]? RequiredPropertiesIndices { get; private set; }
+
         private Action<object>? _onSerializing;
         private Action<object>? _onSerialized;
         private Action<object>? _onDeserializing;
@@ -878,13 +883,38 @@ internal void InitializePropertyCache()
                 ExtensionDataProperty.EnsureConfigured();
             }
 
+            int numberOfRequiredProperties = 0;
+            int propertyIndex = 0;
             foreach (KeyValuePair<string, JsonPropertyInfo> jsonPropertyInfoKv in PropertyCache.List)
             {
                 JsonPropertyInfo jsonPropertyInfo = jsonPropertyInfoKv.Value;
 
+                if (jsonPropertyInfo.IsRequired)
+                {
+                    numberOfRequiredProperties++;
+                }
+
+                jsonPropertyInfo.Index = propertyIndex++;
                 jsonPropertyInfo.EnsureChildOf(this);
                 jsonPropertyInfo.EnsureConfigured();
             }
+
+            if (numberOfRequiredProperties > 0)
+            {
+                int[] requiredPropertiesIndices = new int[numberOfRequiredProperties];
+                int idx = 0;
+                foreach (KeyValuePair<string, JsonPropertyInfo> jsonPropertyInfoKv in PropertyCache.List)
+                {
+                    JsonPropertyInfo jsonPropertyInfo = jsonPropertyInfoKv.Value;
+
+                    if (jsonPropertyInfo.IsRequired)
+                    {
+                        requiredPropertiesIndices[idx++] = jsonPropertyInfo.Index;
+                    }
+                }
+
+                RequiredPropertiesIndices = requiredPropertiesIndices;
+            }
         }
 
         internal void InitializeConstructorParameters(JsonParameterInfoValues[] jsonParameters, bool sourceGenMode = false)

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

@@ -5,6 +5,7 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 using System.Text.Json.Reflection;
 
 namespace System.Text.Json.Serialization.Metadata
@@ -26,6 +27,38 @@ internal ReflectionJsonTypeInfo(JsonConverter converter, JsonSerializerOptions o
             if (PropertyInfoForTypeInfo.ConverterStrategy == ConverterStrategy.Object)
             {
                 AddPropertiesAndParametersUsingReflection();
+
+#if NET7_0_OR_GREATER
+                // Compiler adds RequiredMemberAttribute to type if any of the members is marked with 'required' keyword.
+                // SetsRequiredMembersAttribute means that all required members are assigned by constructor and therefore there is no enforcement
+                bool shouldCheckMembersForRequiredMemberAttribute =
+                    typeof(T).IsDefined(typeof(RequiredMemberAttribute), inherit: true)
+                    && !(converter.ConstructorInfo?.IsDefined(typeof(SetsRequiredMembersAttribute), inherit: true) ?? false);
+
+                if (shouldCheckMembersForRequiredMemberAttribute)
+                {
+                    Debug.Assert(PropertyCache != null);
+                    foreach (var (_, property) in PropertyCache.List)
+                    {
+                        Debug.Assert(property.AttributeProvider != null);
+                        if (property.AttributeProvider.IsDefined(typeof(RequiredMemberAttribute), inherit: true))
+                        {
+                            property.IsRequired = true;
+                        }
+                    }
+
+                    if (ExtensionDataProperty != null)
+                    {
+                        Debug.Assert(ExtensionDataProperty.AttributeProvider != null);
+                        if (ExtensionDataProperty.AttributeProvider.IsDefined(typeof(RequiredMemberAttribute), inherit: true))
+                        {
+                            // This will end up in error in Configure
+                            // but we need to give contract resolver a chance to fix this
+                            ExtensionDataProperty.IsRequired = true;
+                        }
+                    }
+                }
+#endif
             }
 
             Func<object>? createObject = Options.MemberAccessorStrategy.CreateConstructor(typeof(T));