Options Source Gen Fixes (#91363)

tarekgh · web-flow · commit a8d5e7db1c2a · 2023-08-31T16:18:44.000-07:00
diff --git a/src/libraries/Microsoft.Extensions.Options/gen/Emitter.cs b/src/libraries/Microsoft.Extensions.Options/gen/Emitter.cs
@@ -3,10 +3,12 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.DotnetRuntime.Extensions;
 
 namespace Microsoft.Extensions.Options.Generators
 {
@@ -25,6 +27,7 @@ internal sealed class Emitter : EmitterBase
         private string _staticValidationAttributeHolderClassFQN;
         private string _staticValidatorHolderClassFQN;
         private string _modifier;
+        private string _TryGetValueNullableAnnotation;
 
         private sealed record StaticFieldInfo(string FieldTypeFQN, int FieldOrder, string FieldName, IList<string> InstantiationLines);
 
@@ -37,13 +40,14 @@ public Emitter(Compilation compilation, bool emitPreamble = true) : base(emitPre
             else
             {
                 _modifier = "internal";
-                string suffix = $"_{new Random().Next():X8}";
+                string suffix = $"_{GetNonRandomizedHashCode(compilation.SourceModule.Name):X8}";
                 _staticValidationAttributeHolderClassName += suffix;
                 _staticValidatorHolderClassName += suffix;
             }
 
             _staticValidationAttributeHolderClassFQN = $"global::{StaticFieldHolderClassesNamespace}.{_staticValidationAttributeHolderClassName}";
             _staticValidatorHolderClassFQN = $"global::{StaticFieldHolderClassesNamespace}.{_staticValidatorHolderClassName}";
+            _TryGetValueNullableAnnotation = GetNullableAnnotationStringForTryValidateValueToUseInGeneratedCode(compilation);
         }
 
         public string Emit(
@@ -65,6 +69,31 @@ public string Emit(
             return Capture();
         }
 
+        /// <summary>
+        /// Returns the nullable annotation string to use in the code generation according to the first parameter of
+        /// <see cref="System.ComponentModel.DataAnnotations.Validator.TryValidateValue(object, ValidationContext, ICollection{ValidationResult}, IEnumerable{ValidationAttribute})"/> is nullable annotated.
+        /// </summary>
+        /// <param name="compilation">The <see cref="Compilation"/> to consider for analysis.</param>
+        /// <returns>"!" if the first parameter is not nullable annotated, otherwise an empty string.</returns>
+        /// <remarks>
+        /// In .NET 8.0 we have changed the nullable annotation on first parameter of the method cref="System.ComponentModel.DataAnnotations.Validator.TryValidateValue(object, ValidationContext, ICollection{ValidationResult}, IEnumerable{ValidationAttribute})"/>
+        /// The source generator need to detect if we need to append "!" to the first parameter of the method call when running on down-level versions.
+        /// </remarks>
+        private static string GetNullableAnnotationStringForTryValidateValueToUseInGeneratedCode(Compilation compilation)
+        {
+            INamedTypeSymbol? validatorTypeSymbol = compilation.GetBestTypeByMetadataName("System.ComponentModel.DataAnnotations.Validator");
+            if (validatorTypeSymbol is not null)
+            {
+                ImmutableArray<ISymbol> members = validatorTypeSymbol.GetMembers("TryValidateValue");
+                if (members.Length == 1 && members[0] is IMethodSymbol tryValidateValueMethod)
+                {
+                    return tryValidateValueMethod.Parameters[0].NullableAnnotation == NullableAnnotation.NotAnnotated ? "!" : string.Empty;
+                }
+            }
+
+            return "!";
+        }
+
         private void GenValidatorType(ValidatorType vt, ref Dictionary<string, StaticFieldInfo> staticValidationAttributesDict, ref Dictionary<string, StaticFieldInfo> staticValidatorsDict)
         {
             if (vt.Namespace.Length > 0)
@@ -161,7 +190,7 @@ private void GenModelSelfValidationIfNecessary(ValidatedModel modelToValidate)
         {
             if (modelToValidate.SelfValidates)
             {
-                OutLn($"builder.AddResults(((global::System.ComponentModel.DataAnnotations.IValidatableObject)options).Validate(context));");
+                OutLn($"(builder ??= new()).AddResults(((global::System.ComponentModel.DataAnnotations.IValidatableObject)options).Validate(context));");
                 OutLn();
             }
         }
@@ -182,8 +211,7 @@ private void GenModelValidationMethod(
 
             OutLn($"public {(makeStatic ? "static " : string.Empty)}global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, {modelToValidate.Name} options)");
             OutOpenBrace();
-            OutLn($"var baseName = (string.IsNullOrEmpty(name) ? \"{modelToValidate.SimpleName}\" : name) + \".\";");
-            OutLn($"var builder = new global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder();");
+            OutLn($"global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;");
             OutLn($"var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);");
 
             int capacity = modelToValidate.MembersToValidate.Max(static vm => vm.ValidationAttributes.Count);
@@ -199,33 +227,33 @@ private void GenModelValidationMethod(
             {
                 if (vm.ValidationAttributes.Count > 0)
                 {
-                    GenMemberValidation(vm, ref staticValidationAttributesDict, cleanListsBeforeUse);
+                    GenMemberValidation(vm, modelToValidate.SimpleName, ref staticValidationAttributesDict, cleanListsBeforeUse);
                     cleanListsBeforeUse = true;
                     OutLn();
                 }
 
                 if (vm.TransValidatorType is not null)
                 {
-                    GenTransitiveValidation(vm, ref staticValidatorsDict);
+                    GenTransitiveValidation(vm, modelToValidate.SimpleName, ref staticValidatorsDict);
                     OutLn();
                 }
 
                 if (vm.EnumerationValidatorType is not null)
                 {
-                    GenEnumerationValidation(vm, ref staticValidatorsDict);
+                    GenEnumerationValidation(vm, modelToValidate.SimpleName, ref staticValidatorsDict);
                     OutLn();
                 }
             }
 
             GenModelSelfValidationIfNecessary(modelToValidate);
-            OutLn($"return builder.Build();");
+            OutLn($"return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();");
             OutCloseBrace();
         }
 
-        private void GenMemberValidation(ValidatedMember vm, ref Dictionary<string, StaticFieldInfo> staticValidationAttributesDict, bool cleanListsBeforeUse)
+        private void GenMemberValidation(ValidatedMember vm, string modelName, ref Dictionary<string, StaticFieldInfo> staticValidationAttributesDict, bool cleanListsBeforeUse)
         {
             OutLn($"context.MemberName = \"{vm.Name}\";");
-            OutLn($"context.DisplayName = baseName + \"{vm.Name}\";");
+            OutLn($"context.DisplayName = string.IsNullOrEmpty(name) ? \"{modelName}.{vm.Name}\" : $\"{{name}}.{vm.Name}\";");
 
             if (cleanListsBeforeUse)
             {
@@ -239,9 +267,9 @@ private void GenMemberValidation(ValidatedMember vm, ref Dictionary<string, Stat
                 OutLn($"validationAttributes.Add({_staticValidationAttributeHolderClassFQN}.{staticValidationAttributeInstance.FieldName});");
             }
 
-            OutLn($"if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.{vm.Name}!, context, validationResults, validationAttributes))");
+            OutLn($"if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.{vm.Name}{_TryGetValueNullableAnnotation}, context, validationResults, validationAttributes))");
             OutOpenBrace();
-            OutLn($"builder.AddResults(validationResults);");
+            OutLn($"(builder ??= new()).AddResults(validationResults);");
             OutCloseBrace();
         }
 
@@ -305,7 +333,7 @@ private StaticFieldInfo GetOrAddStaticValidationAttribute(ref Dictionary<string,
             return staticValidationAttributeInstance;
         }
 
-        private void GenTransitiveValidation(ValidatedMember vm, ref Dictionary<string, StaticFieldInfo> staticValidatorsDict)
+        private void GenTransitiveValidation(ValidatedMember vm, string modelName, ref Dictionary<string, StaticFieldInfo> staticValidatorsDict)
         {
             string callSequence;
             if (vm.TransValidateTypeIsSynthetic)
@@ -321,20 +349,22 @@ private void GenTransitiveValidation(ValidatedMember vm, ref Dictionary<string,
 
             var valueAccess = (vm.IsNullable && vm.IsValueType) ? ".Value" : string.Empty;
 
+            var baseName = $"string.IsNullOrEmpty(name) ? \"{modelName}.{vm.Name}\" : $\"{{name}}.{vm.Name}\"";
+
             if (vm.IsNullable)
             {
                 OutLn($"if (options.{vm.Name} is not null)");
                 OutOpenBrace();
-                OutLn($"builder.AddResult({callSequence}.Validate(baseName + \"{vm.Name}\", options.{vm.Name}{valueAccess}));");
+                OutLn($"(builder ??= new()).AddResult({callSequence}.Validate({baseName}, options.{vm.Name}{valueAccess}));");
                 OutCloseBrace();
             }
             else
             {
-                OutLn($"builder.AddResult({callSequence}.Validate(baseName + \"{vm.Name}\", options.{vm.Name}{valueAccess}));");
+                OutLn($"(builder ??= new()).AddResult({callSequence}.Validate({baseName}, options.{vm.Name}{valueAccess}));");
             }
         }
 
-        private void GenEnumerationValidation(ValidatedMember vm, ref Dictionary<string, StaticFieldInfo> staticValidatorsDict)
+        private void GenEnumerationValidation(ValidatedMember vm, string modelName, ref Dictionary<string, StaticFieldInfo> staticValidatorsDict)
         {
             var valueAccess = (vm.IsValueType && vm.IsNullable) ? ".Value" : string.Empty;
             var enumeratedValueAccess = (vm.EnumeratedIsNullable && vm.EnumeratedIsValueType) ? ".Value" : string.Empty;
@@ -365,22 +395,25 @@ private void GenEnumerationValidation(ValidatedMember vm, ref Dictionary<string,
             {
                 OutLn($"if (o is not null)");
                 OutOpenBrace();
-                OutLn($"builder.AddResult({callSequence}.Validate(baseName + $\"{vm.Name}[{{count}}]\", o{enumeratedValueAccess}));");
+                var propertyName = $"string.IsNullOrEmpty(name) ? $\"{modelName}.{vm.Name}[{{count}}]\" : $\"{{name}}.{vm.Name}[{{count}}]\"";
+                OutLn($"(builder ??= new()).AddResult({callSequence}.Validate({propertyName}, o{enumeratedValueAccess}));");
                 OutCloseBrace();
 
                 if (!vm.EnumeratedMayBeNull)
                 {
                     OutLn($"else");
                     OutOpenBrace();
-                    OutLn($"builder.AddError(baseName + $\"{vm.Name}[{{count}}] is null\");");
+                    var error = $"string.IsNullOrEmpty(name) ? $\"{modelName}.{vm.Name}[{{count}}] is null\" : $\"{{name}}.{vm.Name}[{{count}}] is null\"";
+                    OutLn($"(builder ??= new()).AddError({error});");
                     OutCloseBrace();
                 }
 
                 OutLn($"count++;");
             }
             else
             {
-                OutLn($"builder.AddResult({callSequence}.Validate(baseName + $\"{vm.Name}[{{count++}}]\", o{enumeratedValueAccess}));");
+                var propertyName = $"string.IsNullOrEmpty(name) ? $\"{modelName}.{vm.Name}[{{count++}}] is null\" : $\"{{name}}.{vm.Name}[{{count++}}] is null\"";
+                OutLn($"(builder ??= new()).AddResult({callSequence}.Validate({propertyName}, o{enumeratedValueAccess}));");
             }
 
             OutCloseBrace();
@@ -405,5 +438,19 @@ private StaticFieldInfo GetOrAddStaticValidator(ref Dictionary<string, StaticFie
 
             return staticValidatorInstance;
         }
+
+        /// <summary>
+        /// Returns a non-randomized hash code for the given string.
+        /// We always return a positive value.
+        /// </summary>
+        internal static int GetNonRandomizedHashCode(string s)
+        {
+            uint result = 2166136261u;
+            foreach (char c in s)
+            {
+                result = (c ^ result) * 16777619;
+            }
+            return Math.Abs((int)result);
+        }
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Options/gen/Microsoft.Extensions.Options.SourceGeneration.csproj b/src/libraries/Microsoft.Extensions.Options/gen/Microsoft.Extensions.Options.SourceGeneration.csproj
@@ -20,6 +20,7 @@
 
   <ItemGroup>
     <Compile Include="$(CoreLibSharedDir)System\Runtime\CompilerServices\IsExternalInit.cs" Link="Common\System\Runtime\CompilerServices\IsExternalInit.cs" />
+    <Compile Include="$(CommonPath)\Roslyn\GetBestTypeByMetadataName.cs" Link="Common\Roslyn\GetBestTypeByMetadataName.cs" />
     <Compile Include="DiagDescriptors.cs" />
     <Compile Include="DiagDescriptorsBase.cs" />
     <Compile Include="Emitter.cs" />
diff --git a/src/libraries/Microsoft.Extensions.Options/gen/Parser.cs b/src/libraries/Microsoft.Extensions.Options/gen/Parser.cs
@@ -240,6 +240,13 @@ private static bool HasOpenGenerics(ITypeSymbol type, out string genericType)
                 type = ((INamedTypeSymbol)type).TypeArguments[0];
             }
 
+            // Check first if the type is IEnumerable<T> interface
+            if (SymbolEqualityComparer.Default.Equals(type.OriginalDefinition, _symbolHolder.GenericIEnumerableSymbol))
+            {
+                return ((INamedTypeSymbol)type).TypeArguments[0];
+            }
+
+            // Check first if the type implement IEnumerable<T> interface
             foreach (var implementingInterface in type.AllInterfaces)
             {
                 if (SymbolEqualityComparer.Default.Equals(implementingInterface.OriginalDefinition, _compilation.GetSpecialType(SpecialType.System_Collections_Generic_IEnumerable_T)))
diff --git a/src/libraries/Microsoft.Extensions.Options/gen/SymbolHolder.cs b/src/libraries/Microsoft.Extensions.Options/gen/SymbolHolder.cs
@@ -14,7 +14,8 @@ internal sealed record class SymbolHolder(
         INamedTypeSymbol DataTypeAttributeSymbol,
         INamedTypeSymbol ValidateOptionsSymbol,
         INamedTypeSymbol IValidatableObjectSymbol,
+        INamedTypeSymbol GenericIEnumerableSymbol,
         INamedTypeSymbol TypeSymbol,
-        INamedTypeSymbol? ValidateObjectMembersAttributeSymbol,
-        INamedTypeSymbol? ValidateEnumeratedItemsAttributeSymbol);
+        INamedTypeSymbol ValidateObjectMembersAttributeSymbol,
+        INamedTypeSymbol ValidateEnumeratedItemsAttributeSymbol);
 }
diff --git a/src/libraries/Microsoft.Extensions.Options/gen/SymbolLoader.cs b/src/libraries/Microsoft.Extensions.Options/gen/SymbolLoader.cs
@@ -15,35 +15,33 @@ internal static class SymbolLoader
         internal const string TypeOfType = "System.Type";
         internal const string ValidateObjectMembersAttribute = "Microsoft.Extensions.Options.ValidateObjectMembersAttribute";
         internal const string ValidateEnumeratedItemsAttribute = "Microsoft.Extensions.Options.ValidateEnumeratedItemsAttribute";
+        internal const string GenericIEnumerableType = "System.Collections.Generic.IEnumerable`1";
 
         public static bool TryLoad(Compilation compilation, out SymbolHolder? symbolHolder)
         {
-            INamedTypeSymbol? GetSymbol(string metadataName, bool optional = false)
-            {
-                var symbol = compilation.GetTypeByMetadataName(metadataName);
-                if (symbol == null && !optional)
-                {
-                    return null;
-                }
-
-                return symbol;
-            }
+            INamedTypeSymbol? GetSymbol(string metadataName) => compilation.GetTypeByMetadataName(metadataName);
 
             // required
             var optionsValidatorSymbol = GetSymbol(OptionsValidatorAttribute);
             var validationAttributeSymbol = GetSymbol(ValidationAttribute);
             var dataTypeAttributeSymbol = GetSymbol(DataTypeAttribute);
             var ivalidatableObjectSymbol = GetSymbol(IValidatableObjectType);
             var validateOptionsSymbol = GetSymbol(IValidateOptionsType);
+            var genericIEnumerableSymbol = GetSymbol(GenericIEnumerableType);
             var typeSymbol = GetSymbol(TypeOfType);
+            var validateObjectMembersAttribute = GetSymbol(ValidateObjectMembersAttribute);
+            var validateEnumeratedItemsAttribute = GetSymbol(ValidateEnumeratedItemsAttribute);
 
     #pragma warning disable S1067 // Expressions should not be too complex
             if (optionsValidatorSymbol == null ||
                 validationAttributeSymbol == null ||
                 dataTypeAttributeSymbol == null ||
                 ivalidatableObjectSymbol == null ||
                 validateOptionsSymbol == null ||
-                typeSymbol == null)
+                genericIEnumerableSymbol == null ||
+                typeSymbol == null ||
+                validateObjectMembersAttribute == null ||
+                validateEnumeratedItemsAttribute == null)
             {
                 symbolHolder = default;
                 return false;
@@ -56,11 +54,10 @@ public static bool TryLoad(Compilation compilation, out SymbolHolder? symbolHold
                 dataTypeAttributeSymbol,
                 validateOptionsSymbol,
                 ivalidatableObjectSymbol,
+                genericIEnumerableSymbol,
                 typeSymbol,
-
-                // optional
-                GetSymbol(ValidateObjectMembersAttribute, optional: true),
-                GetSymbol(ValidateEnumeratedItemsAttribute, optional: true));
+                validateObjectMembersAttribute,
+                validateEnumeratedItemsAttribute);
 
             return true;
         }
diff --git a/src/libraries/Microsoft.Extensions.Options/tests/SourceGeneration.Unit.Tests/Main.cs b/src/libraries/Microsoft.Extensions.Options/tests/SourceGeneration.Unit.Tests/Main.cs
@@ -70,31 +70,30 @@ partial struct MyOptionsValidator
         [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "42.42.42.42")]
         public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::HelloWorld.MyOptions options)
         {
-            var baseName = (string.IsNullOrEmpty(name) ? "MyOptions" : name) + ".";
-            var builder = new global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder();
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
             var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
             var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
             var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(1);
 
             context.MemberName = "Val1";
-            context.DisplayName = baseName + "Val1";
+            context.DisplayName = string.IsNullOrEmpty(name) ? "MyOptions.Val1" : $"{name}.Val1";
             validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
-            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Val1!, context, validationResults, validationAttributes))
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Val1, context, validationResults, validationAttributes))
             {
-                builder.AddResults(validationResults);
+                (builder ??= new()).AddResults(validationResults);
             }
 
             context.MemberName = "Val2";
-            context.DisplayName = baseName + "Val2";
+            context.DisplayName = string.IsNullOrEmpty(name) ? "MyOptions.Val2" : $"{name}.Val2";
             validationResults.Clear();
             validationAttributes.Clear();
             validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A2);
-            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Val2!, context, validationResults, validationAttributes))
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Val2, context, validationResults, validationAttributes))
             {
-                builder.AddResults(validationResults);
+                (builder ??= new()).AddResults(validationResults);
             }
 
-            return builder.Build();
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
         }
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Options/tests/SourceGeneration.Unit.Tests/OptionsRuntimeTests.cs b/src/libraries/Microsoft.Extensions.Options/tests/SourceGeneration.Unit.Tests/OptionsRuntimeTests.cs
diff --git a/src/libraries/Microsoft.Extensions.Options/tests/SourceGenerationTests/Baselines/NetCoreApp/Validators.g.cs b/src/libraries/Microsoft.Extensions.Options/tests/SourceGenerationTests/Baselines/NetCoreApp/Validators.g.cs
diff --git a/src/libraries/Microsoft.Extensions.Options/tests/SourceGenerationTests/Baselines/NetFX/Validators.g.cs b/src/libraries/Microsoft.Extensions.Options/tests/SourceGenerationTests/Baselines/NetFX/Validators.g.cs

Original file line number	Diff line number	Diff line change
`@@ -3,10 +3,12 @@`
`3`	`3`
`4`	`4`	`using System;`
`5`	`5`	`using System.Collections.Generic;`
	`6`	`+using System.Collections.Immutable;`
`6`	`7`	`using System.Linq;`
`7`	`8`	`using System.Threading;`
`8`	`9`	`using Microsoft.CodeAnalysis;`
`9`	`10`	`using Microsoft.CodeAnalysis.CSharp;`
	`11`	`+using Microsoft.CodeAnalysis.DotnetRuntime.Extensions;`
`10`	`12`
`11`	`13`	`namespace Microsoft.Extensions.Options.Generators`
`12`	`14`	`{`
`@@ -25,6 +27,7 @@ internal sealed class Emitter : EmitterBase`
`25`	`27`	`private string _staticValidationAttributeHolderClassFQN;`
`26`	`28`	`private string _staticValidatorHolderClassFQN;`
`27`	`29`	`private string _modifier;`
	`30`	`+ private string _TryGetValueNullableAnnotation;`
`28`	`31`
`29`	`32`	`private sealed record StaticFieldInfo(string FieldTypeFQN, int FieldOrder, string FieldName, IList<string> InstantiationLines);`
`30`	`33`
`@@ -37,13 +40,14 @@ public Emitter(Compilation compilation, bool emitPreamble = true) : base(emitPre`
`37`	`40`	`else`
`38`	`41`	`{`
`39`	`42`	`_modifier = "internal";`
`40`		`- string suffix = $"_{new Random().Next():X8}";`
	`43`	`+ string suffix = $"_{GetNonRandomizedHashCode(compilation.SourceModule.Name):X8}";`
`41`	`44`	`_staticValidationAttributeHolderClassName += suffix;`
`42`	`45`	`_staticValidatorHolderClassName += suffix;`
`43`	`46`	`}`
`44`	`47`
`45`	`48`	`_staticValidationAttributeHolderClassFQN = $"global::{StaticFieldHolderClassesNamespace}.{_staticValidationAttributeHolderClassName}";`
`46`	`49`	`_staticValidatorHolderClassFQN = $"global::{StaticFieldHolderClassesNamespace}.{_staticValidatorHolderClassName}";`
	`50`	`+ _TryGetValueNullableAnnotation = GetNullableAnnotationStringForTryValidateValueToUseInGeneratedCode(compilation);`
`47`	`51`	`}`
`48`	`52`
`49`	`53`	`public string Emit(`
`@@ -65,6 +69,31 @@ public string Emit(`
`65`	`69`	`return Capture();`
`66`	`70`	`}`
`67`	`71`
	`72`	`+ /// <summary>`
	`73`	`+ /// Returns the nullable annotation string to use in the code generation according to the first parameter of`
	`74`	`+ /// <see cref="System.ComponentModel.DataAnnotations.Validator.TryValidateValue(object, ValidationContext, ICollection{ValidationResult}, IEnumerable{ValidationAttribute})"/> is nullable annotated.`
	`75`	`+ /// </summary>`
	`76`	`+ /// <param name="compilation">The <see cref="Compilation"/> to consider for analysis.</param>`
	`77`	`+ /// <returns>"!" if the first parameter is not nullable annotated, otherwise an empty string.</returns>`
	`78`	`+ /// <remarks>`
	`79`	`+ /// In .NET 8.0 we have changed the nullable annotation on first parameter of the method cref="System.ComponentModel.DataAnnotations.Validator.TryValidateValue(object, ValidationContext, ICollection{ValidationResult}, IEnumerable{ValidationAttribute})"/>`
	`80`	`+ /// The source generator need to detect if we need to append "!" to the first parameter of the method call when running on down-level versions.`
	`81`	`+ /// </remarks>`
	`82`	`+ private static string GetNullableAnnotationStringForTryValidateValueToUseInGeneratedCode(Compilation compilation)`
	`83`	`+ {`
	`84`	`+ INamedTypeSymbol? validatorTypeSymbol = compilation.GetBestTypeByMetadataName("System.ComponentModel.DataAnnotations.Validator");`
	`85`	`+ if (validatorTypeSymbol is not null)`
	`86`	`+ {`
	`87`	`+ ImmutableArray<ISymbol> members = validatorTypeSymbol.GetMembers("TryValidateValue");`
	`88`	`+ if (members.Length == 1 && members[0] is IMethodSymbol tryValidateValueMethod)`
	`89`	`+ {`
	`90`	`+ return tryValidateValueMethod.Parameters[0].NullableAnnotation == NullableAnnotation.NotAnnotated ? "!" : string.Empty;`
	`91`	`+ }`
	`92`	`+ }`
	`93`	`+`
	`94`	`+ return "!";`
	`95`	`+ }`
	`96`	`+`
`68`	`97`	`private void GenValidatorType(ValidatorType vt, ref Dictionary<string, StaticFieldInfo> staticValidationAttributesDict, ref Dictionary<string, StaticFieldInfo> staticValidatorsDict)`
`69`	`98`	`{`
`70`	`99`	`if (vt.Namespace.Length > 0)`
`@@ -161,7 +190,7 @@ private void GenModelSelfValidationIfNecessary(ValidatedModel modelToValidate)`
`161`	`190`	`{`
`162`	`191`	`if (modelToValidate.SelfValidates)`
`163`	`192`	`{`
`164`		`- OutLn($"builder.AddResults(((global::System.ComponentModel.DataAnnotations.IValidatableObject)options).Validate(context));");`
	`193`	`+ OutLn($"(builder ??= new()).AddResults(((global::System.ComponentModel.DataAnnotations.IValidatableObject)options).Validate(context));");`
`165`	`194`	`OutLn();`
`166`	`195`	`}`
`167`	`196`	`}`
`@@ -182,8 +211,7 @@ private void GenModelValidationMethod(`
`182`	`211`
`183`	`212`	`OutLn($"public {(makeStatic ? "static " : string.Empty)}global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, {modelToValidate.Name} options)");`
`184`	`213`	`OutOpenBrace();`
`185`		`- OutLn($"var baseName = (string.IsNullOrEmpty(name) ? \"{modelToValidate.SimpleName}\" : name) + \".\";");`
`186`		`- OutLn($"var builder = new global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder();");`
	`214`	`+ OutLn($"global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;");`
`187`	`215`	`OutLn($"var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);");`
`188`	`216`
`189`	`217`	`int capacity = modelToValidate.MembersToValidate.Max(static vm => vm.ValidationAttributes.Count);`
`@@ -199,33 +227,33 @@ private void GenModelValidationMethod(`
`199`	`227`	`{`
`200`	`228`	`if (vm.ValidationAttributes.Count > 0)`
`201`	`229`	`{`
`202`		`- GenMemberValidation(vm, ref staticValidationAttributesDict, cleanListsBeforeUse);`
	`230`	`+ GenMemberValidation(vm, modelToValidate.SimpleName, ref staticValidationAttributesDict, cleanListsBeforeUse);`
`203`	`231`	`cleanListsBeforeUse = true;`
`204`	`232`	`OutLn();`
`205`	`233`	`}`
`206`	`234`
`207`	`235`	`if (vm.TransValidatorType is not null)`
`208`	`236`	`{`
`209`		`- GenTransitiveValidation(vm, ref staticValidatorsDict);`
	`237`	`+ GenTransitiveValidation(vm, modelToValidate.SimpleName, ref staticValidatorsDict);`
`210`	`238`	`OutLn();`
`211`	`239`	`}`
`212`	`240`
`213`	`241`	`if (vm.EnumerationValidatorType is not null)`
`214`	`242`	`{`
`215`		`- GenEnumerationValidation(vm, ref staticValidatorsDict);`
	`243`	`+ GenEnumerationValidation(vm, modelToValidate.SimpleName, ref staticValidatorsDict);`
`216`	`244`	`OutLn();`
`217`	`245`	`}`
`218`	`246`	`}`
`219`	`247`
`220`	`248`	`GenModelSelfValidationIfNecessary(modelToValidate);`
`221`		`- OutLn($"return builder.Build();");`
	`249`	`+ OutLn($"return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();");`
`222`	`250`	`OutCloseBrace();`
`223`	`251`	`}`
`224`	`252`
`225`		`- private void GenMemberValidation(ValidatedMember vm, ref Dictionary<string, StaticFieldInfo> staticValidationAttributesDict, bool cleanListsBeforeUse)`
	`253`	`+ private void GenMemberValidation(ValidatedMember vm, string modelName, ref Dictionary<string, StaticFieldInfo> staticValidationAttributesDict, bool cleanListsBeforeUse)`
`226`	`254`	`{`
`227`	`255`	`OutLn($"context.MemberName = \"{vm.Name}\";");`
`228`		`- OutLn($"context.DisplayName = baseName + \"{vm.Name}\";");`
	`256`	`+ OutLn($"context.DisplayName = string.IsNullOrEmpty(name) ? \"{modelName}.{vm.Name}\" : $\"{{name}}.{vm.Name}\";");`
`229`	`257`
`230`	`258`	`if (cleanListsBeforeUse)`
`231`	`259`	`{`
`@@ -239,9 +267,9 @@ private void GenMemberValidation(ValidatedMember vm, ref Dictionary<string, Stat`
`239`	`267`	`OutLn($"validationAttributes.Add({_staticValidationAttributeHolderClassFQN}.{staticValidationAttributeInstance.FieldName});");`
`240`	`268`	`}`
`241`	`269`
`242`		`- OutLn($"if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.{vm.Name}!, context, validationResults, validationAttributes))");`
	`270`	`+ OutLn($"if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.{vm.Name}{_TryGetValueNullableAnnotation}, context, validationResults, validationAttributes))");`
`243`	`271`	`OutOpenBrace();`
`244`		`- OutLn($"builder.AddResults(validationResults);");`
	`272`	`+ OutLn($"(builder ??= new()).AddResults(validationResults);");`
`245`	`273`	`OutCloseBrace();`
`246`	`274`	`}`
`247`	`275`
`@@ -305,7 +333,7 @@ private StaticFieldInfo GetOrAddStaticValidationAttribute(ref Dictionary<string,`
`305`	`333`	`return staticValidationAttributeInstance;`
`306`	`334`	`}`
`307`	`335`
`308`		`- private void GenTransitiveValidation(ValidatedMember vm, ref Dictionary<string, StaticFieldInfo> staticValidatorsDict)`
	`336`	`+ private void GenTransitiveValidation(ValidatedMember vm, string modelName, ref Dictionary<string, StaticFieldInfo> staticValidatorsDict)`
`309`	`337`	`{`
`310`	`338`	`string callSequence;`
`311`	`339`	`if (vm.TransValidateTypeIsSynthetic)`
`@@ -321,20 +349,22 @@ private void GenTransitiveValidation(ValidatedMember vm, ref Dictionary<string,`
`321`	`349`
`322`	`350`	`var valueAccess = (vm.IsNullable && vm.IsValueType) ? ".Value" : string.Empty;`
`323`	`351`
	`352`	`+ var baseName = $"string.IsNullOrEmpty(name) ? \"{modelName}.{vm.Name}\" : $\"{{name}}.{vm.Name}\"";`
	`353`	`+`
`324`	`354`	`if (vm.IsNullable)`
`325`	`355`	`{`
`326`	`356`	`OutLn($"if (options.{vm.Name} is not null)");`
`327`	`357`	`OutOpenBrace();`
`328`		`- OutLn($"builder.AddResult({callSequence}.Validate(baseName + \"{vm.Name}\", options.{vm.Name}{valueAccess}));");`
	`358`	`+ OutLn($"(builder ??= new()).AddResult({callSequence}.Validate({baseName}, options.{vm.Name}{valueAccess}));");`
`329`	`359`	`OutCloseBrace();`
`330`	`360`	`}`
`331`	`361`	`else`
`332`	`362`	`{`
`333`		`- OutLn($"builder.AddResult({callSequence}.Validate(baseName + \"{vm.Name}\", options.{vm.Name}{valueAccess}));");`
	`363`	`+ OutLn($"(builder ??= new()).AddResult({callSequence}.Validate({baseName}, options.{vm.Name}{valueAccess}));");`
`334`	`364`	`}`
`335`	`365`	`}`
`336`	`366`
`337`		`- private void GenEnumerationValidation(ValidatedMember vm, ref Dictionary<string, StaticFieldInfo> staticValidatorsDict)`
	`367`	`+ private void GenEnumerationValidation(ValidatedMember vm, string modelName, ref Dictionary<string, StaticFieldInfo> staticValidatorsDict)`
`338`	`368`	`{`
`339`	`369`	`var valueAccess = (vm.IsValueType && vm.IsNullable) ? ".Value" : string.Empty;`
`340`	`370`	`var enumeratedValueAccess = (vm.EnumeratedIsNullable && vm.EnumeratedIsValueType) ? ".Value" : string.Empty;`
`@@ -365,22 +395,25 @@ private void GenEnumerationValidation(ValidatedMember vm, ref Dictionary<string,`
`365`	`395`	`{`
`366`	`396`	`OutLn($"if (o is not null)");`
`367`	`397`	`OutOpenBrace();`
`368`		`- OutLn($"builder.AddResult({callSequence}.Validate(baseName + $\"{vm.Name}[{{count}}]\", o{enumeratedValueAccess}));");`
	`398`	`+ var propertyName = $"string.IsNullOrEmpty(name) ? $\"{modelName}.{vm.Name}[{{count}}]\" : $\"{{name}}.{vm.Name}[{{count}}]\"";`
	`399`	`+ OutLn($"(builder ??= new()).AddResult({callSequence}.Validate({propertyName}, o{enumeratedValueAccess}));");`
`369`	`400`	`OutCloseBrace();`
`370`	`401`
`371`	`402`	`if (!vm.EnumeratedMayBeNull)`
`372`	`403`	`{`
`373`	`404`	`OutLn($"else");`
`374`	`405`	`OutOpenBrace();`
`375`		`- OutLn($"builder.AddError(baseName + $\"{vm.Name}[{{count}}] is null\");");`
	`406`	`+ var error = $"string.IsNullOrEmpty(name) ? $\"{modelName}.{vm.Name}[{{count}}] is null\" : $\"{{name}}.{vm.Name}[{{count}}] is null\"";`
	`407`	`+ OutLn($"(builder ??= new()).AddError({error});");`
`376`	`408`	`OutCloseBrace();`
`377`	`409`	`}`
`378`	`410`
`379`	`411`	`OutLn($"count++;");`
`380`	`412`	`}`
`381`	`413`	`else`
`382`	`414`	`{`
`383`		`- OutLn($"builder.AddResult({callSequence}.Validate(baseName + $\"{vm.Name}[{{count++}}]\", o{enumeratedValueAccess}));");`
	`415`	`+ var propertyName = $"string.IsNullOrEmpty(name) ? $\"{modelName}.{vm.Name}[{{count++}}] is null\" : $\"{{name}}.{vm.Name}[{{count++}}] is null\"";`
	`416`	`+ OutLn($"(builder ??= new()).AddResult({callSequence}.Validate({propertyName}, o{enumeratedValueAccess}));");`
`384`	`417`	`}`
`385`	`418`
`386`	`419`	`OutCloseBrace();`
`@@ -405,5 +438,19 @@ private StaticFieldInfo GetOrAddStaticValidator(ref Dictionary<string, StaticFie`
`405`	`438`
`406`	`439`	`return staticValidatorInstance;`
`407`	`440`	`}`
	`441`	`+`
	`442`	`+ /// <summary>`
	`443`	`+ /// Returns a non-randomized hash code for the given string.`
	`444`	`+ /// We always return a positive value.`
	`445`	`+ /// </summary>`
	`446`	`+ internal static int GetNonRandomizedHashCode(string s)`
	`447`	`+ {`
	`448`	`+ uint result = 2166136261u;`
	`449`	`+ foreach (char c in s)`
	`450`	`+ {`
	`451`	`+ result = (c ^ result) * 16777619;`
	`452`	`+ }`
	`453`	`+ return Math.Abs((int)result);`
	`454`	`+ }`
`408`	`455`	`}`
`409`	`456`	`}`
Original file line number	Diff line number	Diff line change
`@@ -240,6 +240,13 @@ private static bool HasOpenGenerics(ITypeSymbol type, out string genericType)`
`240`	`240`	`type = ((INamedTypeSymbol)type).TypeArguments[0];`
`241`	`241`	`}`
`242`	`242`
	`243`	`+ // Check first if the type is IEnumerable<T> interface`
	`244`	`+ if (SymbolEqualityComparer.Default.Equals(type.OriginalDefinition, _symbolHolder.GenericIEnumerableSymbol))`
	`245`	`+ {`
	`246`	`+ return ((INamedTypeSymbol)type).TypeArguments[0];`
	`247`	`+ }`
	`248`	`+`
	`249`	`+ // Check first if the type implement IEnumerable<T> interface`
`243`	`250`	`foreach (var implementingInterface in type.AllInterfaces)`
`244`	`251`	`{`
`245`	`252`	`if (SymbolEqualityComparer.Default.Equals(implementingInterface.OriginalDefinition, _compilation.GetSpecialType(SpecialType.System_Collections_Generic_IEnumerable_T)))`
Original file line number	Diff line number	Diff line change
`@@ -70,31 +70,30 @@ partial struct MyOptionsValidator`
`70`	`70`	`[global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "42.42.42.42")]`
`71`	`71`	`public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::HelloWorld.MyOptions options)`
`72`	`72`	`{`
`73`		`- var baseName = (string.IsNullOrEmpty(name) ? "MyOptions" : name) + ".";`
`74`		`- var builder = new global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder();`
	`73`	`+ global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;`
`75`	`74`	`var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);`
`76`	`75`	`var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();`
`77`	`76`	`var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(1);`
`78`	`77`
`79`	`78`	`context.MemberName = "Val1";`
`80`		`- context.DisplayName = baseName + "Val1";`
	`79`	`+ context.DisplayName = string.IsNullOrEmpty(name) ? "MyOptions.Val1" : $"{name}.Val1";`
`81`	`80`	`validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);`
`82`		`- if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Val1!, context, validationResults, validationAttributes))`
	`81`	`+ if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Val1, context, validationResults, validationAttributes))`
`83`	`82`	`{`
`84`		`- builder.AddResults(validationResults);`
	`83`	`+ (builder ??= new()).AddResults(validationResults);`
`85`	`84`	`}`
`86`	`85`
`87`	`86`	`context.MemberName = "Val2";`
`88`		`- context.DisplayName = baseName + "Val2";`
	`87`	`+ context.DisplayName = string.IsNullOrEmpty(name) ? "MyOptions.Val2" : $"{name}.Val2";`
`89`	`88`	`validationResults.Clear();`
`90`	`89`	`validationAttributes.Clear();`
`91`	`90`	`validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A2);`
`92`		`- if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Val2!, context, validationResults, validationAttributes))`
	`91`	`+ if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Val2, context, validationResults, validationAttributes))`
`93`	`92`	`{`
`94`		`- builder.AddResults(validationResults);`
	`93`	`+ (builder ??= new()).AddResults(validationResults);`
`95`	`94`	`}`
`96`	`95`
`97`		`- return builder.Build();`
	`96`	`+ return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();`
`98`	`97`	`}`
`99`	`98`	`}`
`100`	`99`	`}`