Slightly improved perf of source gen and analyzers

PawelGerr · PawelGerr · commit b65d08973785 · 2024-12-11T20:59:53.000+01:00
diff --git a/Directory.Build.props b/Directory.Build.props
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <Copyright>(c) $([System.DateTime]::Now.Year), Pawel Gerr. All rights reserved.</Copyright>
-    <VersionPrefix>8.0.0</VersionPrefix>
+    <VersionPrefix>8.0.1</VersionPrefix>
     <Authors>Pawel Gerr</Authors>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <PackageProjectUrl>https://github.com/PawelGerr/Thinktecture.Runtime.Extensions</PackageProjectUrl>
diff --git a/samples/Directory.Build.props b/samples/Directory.Build.props
@@ -12,6 +12,7 @@
     <IsPackable>false</IsPackable>
     <ImplicitUsings>disable</ImplicitUsings>
     <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
+    <ReportAnalyzer>true</ReportAnalyzer>
     <ThinktectureRuntimeExtensions_SourceGenerator_LogFilePathMustBeUnique>false</ThinktectureRuntimeExtensions_SourceGenerator_LogFilePathMustBeUnique>
     <ThinktectureRuntimeExtensions_SourceGenerator_LogFilePath>C:\temp\ttre_samples_logs.txt</ThinktectureRuntimeExtensions_SourceGenerator_LogFilePath>
   </PropertyGroup>
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/AdHocUnions/AdHocUnionSourceGenerator.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/AdHocUnions/AdHocUnionSourceGenerator.cs
@@ -120,9 +120,9 @@ private bool IsUnionCandidate(TypeDeclarationSyntax typeDeclaration)
             return null;
          }
 
-         if (attributeType.TypeArguments.Length < 2)
+         if (attributeType.Arity < 2)
          {
-            Logger.LogDebug($"Expected the attribute type to have at least 2 type arguments but found {attributeType.TypeArguments.Length.ToString()}", tds);
+            Logger.LogDebug($"Expected the attribute type to have at least 2 type arguments but found {attributeType.Arity.ToString()}", tds);
             return null;
          }
 
@@ -140,9 +140,9 @@ private bool IsUnionCandidate(TypeDeclarationSyntax typeDeclaration)
             return new SourceGenContext(new SourceGenError("Could not fetch type information for code generation of a discriminated union", tds));
 
          var settings = new AdHocUnionSettings(context.Attributes[0],
-                                               attributeType.TypeArguments.Length,
+                                               attributeType.Arity,
                                                attributeInfo);
-         var memberTypeStates = new AdHocUnionMemberTypeState[attributeType.TypeArguments.Length];
+         var memberTypeStates = attributeType.Arity == 0 ? [] : new AdHocUnionMemberTypeState[attributeType.Arity];
 
          for (var i = 0; i < attributeType.TypeArguments.Length; i++)
          {
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/Diagnostics/ThinktectureRuntimeExtensionsAnalyzer.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/Diagnostics/ThinktectureRuntimeExtensionsAnalyzer.cs
@@ -144,8 +144,7 @@ private static void AnalyzeMethodCall(OperationAnalysisContext context)
       if (declaredType.IsEnum(out var attribute))
       {
          var isValidatable = attribute.FindIsValidatable() ?? false;
-         var nonIgnoredMembers = declaredType.GetNonIgnoredMembers();
-         var items = declaredType.GetEnumItems(nonIgnoredMembers);
+         var items = declaredType.GetEnumItems();
 
          AnalyzeEnumSwitchMap(context,
                               items,
@@ -482,16 +481,15 @@ private static void ValidateCustomKeyMemberImplementation(
       TypeMustBePartial(context, type);
       TypeMustNotBeGeneric(context, type, locationOfFirstDeclaration, "Value Object");
 
-      var nonIgnoredItems = type.GetNonIgnoredMembers();
-      var assignableMembers = type.GetAssignableFieldsAndPropertiesAndCheckForReadOnly(nonIgnoredItems, factory, false, true, context.CancellationToken, context)
+      var assignableMembers = type.GetAssignableFieldsAndPropertiesAndCheckForReadOnly(factory, false, true, context.CancellationToken, context)
                                   .Where(m => !m.IsStatic)
                                   .ToList();
 
       var baseClass = type.BaseType;
 
       while (!baseClass.IsNullOrObject())
       {
-         baseClass.IterateAssignableFieldsAndPropertiesAndCheckForReadOnly(baseClass.GetNonIgnoredMembers(), false, context.CancellationToken, locationOfFirstDeclaration, context).Enumerate();
+         baseClass.IterateAssignableFieldsAndPropertiesAndCheckForReadOnly(false, context.CancellationToken, locationOfFirstDeclaration, context).Enumerate();
 
          baseClass = baseClass.BaseType;
       }
@@ -557,22 +555,21 @@ private static void ValidateEnum(
       TypeMustBePartial(context, enumType);
       TypeMustNotBeGeneric(context, enumType, locationOfFirstDeclaration, "Enumeration");
 
-      var nonIgnoredMembers = enumType.GetNonIgnoredMembers();
-      var items = enumType.GetEnumItems(nonIgnoredMembers);
+      var items = enumType.GetEnumItems();
 
       if (items.Length == 0)
          ReportDiagnostic(context, DiagnosticsDescriptors.EnumerationHasNoItems, locationOfFirstDeclaration, enumType);
 
-      Check_ItemLike_StaticProperties(context, enumType, nonIgnoredMembers);
+      Check_ItemLike_StaticProperties(context, enumType);
       EnumItemsMustBePublic(context, enumType, items);
 
-      _ = enumType.GetAssignableFieldsAndPropertiesAndCheckForReadOnly(nonIgnoredMembers, factory, false, false, context.CancellationToken, context).ToList();
+      _ = enumType.GetAssignableFieldsAndPropertiesAndCheckForReadOnly(factory, false, false, context.CancellationToken, context).ToList();
 
       var baseClass = enumType.BaseType;
 
       while (!baseClass.IsNullOrObject())
       {
-         baseClass.IterateAssignableFieldsAndPropertiesAndCheckForReadOnly(baseClass.GetNonIgnoredMembers(), false, context.CancellationToken, locationOfFirstDeclaration, context).Enumerate();
+         baseClass.IterateAssignableFieldsAndPropertiesAndCheckForReadOnly(false, context.CancellationToken, locationOfFirstDeclaration, context).Enumerate();
 
          baseClass = baseClass.BaseType;
       }
@@ -581,14 +578,13 @@ private static void ValidateEnum(
 
       EnumKeyMemberNameMustNotBeItem(context, attribute, locationOfFirstDeclaration);
 
-      ValidateKeyedSmartEnum(context, enumType, attribute, nonIgnoredMembers, locationOfFirstDeclaration);
+      ValidateKeyedSmartEnum(context, enumType, attribute, locationOfFirstDeclaration);
    }
 
    private static void ValidateKeyedSmartEnum(
       OperationAnalysisContext context,
       INamedTypeSymbol enumType,
       IObjectCreationOperation attribute,
-      ImmutableArray<ISymbol> nonIgnoredMembers,
       Location locationOfFirstDeclaration)
    {
       var keyType = (attribute.Type as INamedTypeSymbol)?.TypeArguments.FirstOrDefault();
@@ -609,7 +605,7 @@ private static void ValidateKeyedSmartEnum(
 
       if (isValidatable)
       {
-         ValidateCreateInvalidItem(context, enumType, keyType, nonIgnoredMembers, locationOfFirstDeclaration);
+         ValidateCreateInvalidItem(context, enumType, keyType, locationOfFirstDeclaration);
       }
       else if (enumType.IsValueType)
       {
@@ -627,14 +623,15 @@ private static void TypeMustNotBeGeneric(OperationAnalysisContext context, IName
 
    private static void Check_ItemLike_StaticProperties(
       OperationAnalysisContext context,
-      INamedTypeSymbol enumType,
-      ImmutableArray<ISymbol> nonIgnoredMembers)
+      INamedTypeSymbol enumType)
    {
-      for (var i = 0; i < nonIgnoredMembers.Length; i++)
+      var members = enumType.GetMembers();
+
+      for (var i = 0; i < members.Length; i++)
       {
-         var member = nonIgnoredMembers[i];
+         var member = members[i];
 
-         if (member.IsStatic && member is IPropertySymbol property && SymbolEqualityComparer.Default.Equals(property.Type, enumType))
+         if (member.IsStatic && member is IPropertySymbol property && SymbolEqualityComparer.Default.Equals(property.Type, enumType) && !property.IsIgnored())
             ReportDiagnostic(context, DiagnosticsDescriptors.StaticPropertiesAreNotConsideredItems, property.GetIdentifier(context.CancellationToken)?.GetLocation() ?? Location.None, property.Name);
       }
    }
@@ -680,10 +677,9 @@ private static void ValidateCreateInvalidItem(
       OperationAnalysisContext context,
       INamedTypeSymbol enumType,
       ITypeSymbol keyType,
-      ImmutableArray<ISymbol> nonIgnoredMembers,
       Location location)
    {
-      var hasCreateInvalidItemImplementation = enumType.HasCreateInvalidItemImplementation(nonIgnoredMembers, keyType, context.CancellationToken, context);
+      var hasCreateInvalidItemImplementation = enumType.HasCreateInvalidItemImplementation(keyType, context.CancellationToken, context);
 
       if (!hasCreateInvalidItemImplementation && enumType.IsAbstract)
       {
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/SmartEnums/EnumSourceGeneratorState.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/SmartEnums/EnumSourceGeneratorState.cs
@@ -30,7 +30,6 @@ public EnumSourceGeneratorState(
       INamedTypeSymbol type,
       KeyMemberState? keyMember,
       ValidationErrorState validationError,
-      ImmutableArray<ISymbol> nonIgnoredMembers,
       EnumSettings settings,
       bool hasCreateInvalidItemImplementation,
       bool hasDerivedTypes,
@@ -53,8 +52,8 @@ public EnumSourceGeneratorState(
       IsAbstract = type.IsAbstract;
 
       BaseType = type.GetBaseType(factory);
-      Items = new EnumItems(type.GetEnumItems(nonIgnoredMembers));
-      AssignableInstanceFieldsAndProperties = type.GetAssignableFieldsAndPropertiesAndCheckForReadOnly(nonIgnoredMembers, factory, true, false, cancellationToken).ToList();
+      Items = new EnumItems(type.GetEnumItems());
+      AssignableInstanceFieldsAndProperties = type.GetAssignableFieldsAndPropertiesAndCheckForReadOnly(factory, true, false, cancellationToken).ToList();
    }
 
    public override bool Equals(object? obj)
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/SmartEnums/SmartEnumSourceGenerator.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/SmartEnums/SmartEnumSourceGenerator.cs
@@ -350,9 +350,9 @@ private bool IsEnumCandidate(TypeDeclarationSyntax typeDeclaration)
                return null;
             }
 
-            if (attributetype.TypeArguments.Length != 1)
+            if (attributetype.Arity != 1)
             {
-               Logger.LogDebug($"Expected the attribute type to have 1 type argument but found {attributetype.TypeArguments.Length.ToString()}", tds);
+               Logger.LogDebug($"Expected the attribute type to have 1 type argument but found {attributetype.Arity.ToString()}", tds);
                return null;
             }
 
@@ -393,15 +393,13 @@ private bool IsEnumCandidate(TypeDeclarationSyntax typeDeclaration)
             keyMember = settings.CreateKeyMember(keyTypedMemberState);
          }
 
-         var nonIgnoredMembers = type.GetNonIgnoredMembers();
-         var hasCreateInvalidItemImplementation = keyMemberType is not null && settings.IsValidatable && type.HasCreateInvalidItemImplementation(nonIgnoredMembers, keyMemberType, cancellationToken);
+         var hasCreateInvalidItemImplementation = keyMemberType is not null && settings.IsValidatable && type.HasCreateInvalidItemImplementation(keyMemberType, cancellationToken);
 
          var derivedTypeNames = FindDerivedTypes(type);
          var enumState = new EnumSourceGeneratorState(factory,
                                                       type,
                                                       keyMember,
                                                       attributeInfo.ValidationError,
-                                                      nonIgnoredMembers,
                                                       new EnumSettings(settings, attributeInfo),
                                                       hasCreateInvalidItemImplementation,
                                                       derivedTypeNames.Count > 0,
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/TypedMemberState.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/TypedMemberState.cs
@@ -143,13 +143,13 @@ public TypedMemberState(ITypeSymbol type)
 
    private static bool IsToStringNullable(ITypeSymbol type)
    {
-      var array = type.GetMembers();
+      var array = type.GetMembers("ToString");
 
       for (var i = 0; i < array.Length; i++)
       {
          var member = array[i];
 
-         if (member is not IMethodSymbol { Name: "ToString" } toString)
+         if (member is not IMethodSymbol toString)
             continue;
 
          return toString.ReturnNullableAnnotation == NullableAnnotation.Annotated;
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/Unions/UnionSourceGenState.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/Unions/UnionSourceGenState.cs
@@ -22,7 +22,7 @@ public UnionSourceGenState(
       Namespace = type.ContainingNamespace?.IsGlobalNamespace == true ? null : type.ContainingNamespace?.ToString();
       HasNonDefaultConstructor = !type.Constructors.IsDefaultOrEmpty && type.Constructors.Any(c => !c.IsImplicitlyDeclared);
       ContainingTypes = type.GetContainingTypes();
-      GenericsFullyQualified = type.TypeArguments.Length == 0
+      GenericsFullyQualified = type.Arity == 0
                                   ? []
                                   : type.TypeArguments.Select(t => t.ToFullyQualifiedDisplayString()).ToList();
 
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/Unions/UnionSourceGenerator.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/Unions/UnionSourceGenerator.cs
@@ -89,9 +89,9 @@ private bool IsCandidate(SyntaxNode syntaxNode, CancellationToken cancellationTo
             return null;
          }
 
-         if (attributeType.TypeArguments.Length != 0)
+         if (attributeType.Arity != 0)
          {
-            Logger.LogDebug($"Expected the union attribute type to have no type arguments but found {attributeType.TypeArguments.Length.ToString()}", tds);
+            Logger.LogDebug($"Expected the union attribute type to have no type arguments but found {attributeType.Arity.ToString()}", tds);
             return null;
          }
 
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/ValueObjects/ComplexValueObjectSourceGeneratorState.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/ValueObjects/ComplexValueObjectSourceGeneratorState.cs
@@ -40,13 +40,10 @@ public ComplexValueObjectSourceGeneratorState(
       NullableAnnotation = type.NullableAnnotation;
       IsNullableStruct = type.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T;
 
-      var nonIgnoredMembers = type.GetNonIgnoredMembers();
-      AssignableInstanceFieldsAndProperties = type.GetAssignableFieldsAndPropertiesAndCheckForReadOnly(nonIgnoredMembers, factory, true, true, cancellationToken).ToList();
+      AssignableInstanceFieldsAndProperties = type.GetAssignableFieldsAndPropertiesAndCheckForReadOnly(factory, true, true, cancellationToken).ToList();
       EqualityMembers = GetEqualityMembers();
 
-      var factoryValidationReturnType = nonIgnoredMembers.IsDefaultOrEmpty
-                                           ? null
-                                           : (nonIgnoredMembers.FirstOrDefault(m => m.IsStatic && m.Name == Constants.Methods.VALIDATE_FACTORY_ARGUMENTS && m is IMethodSymbol method && method.ReturnType.SpecialType != SpecialType.System_Void) as IMethodSymbol)?.ReturnType;
+      var factoryValidationReturnType = (type.GetMembers().FirstOrDefault(m => m.IsStatic && m.Name == Constants.Methods.VALIDATE_FACTORY_ARGUMENTS && m is IMethodSymbol method && method.ReturnType.SpecialType != SpecialType.System_Void) as IMethodSymbol)?.ReturnType;
 
       if (factoryValidationReturnType is not null)
          FactoryValidationReturnType = factoryValidationReturnType.ToFullyQualifiedDisplayString();
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/ValueObjects/KeyedValueObjectSourceGeneratorState.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/ValueObjects/KeyedValueObjectSourceGeneratorState.cs
@@ -38,11 +38,11 @@ public KeyedValueObjectSourceGeneratorState(
       NullableAnnotation = type.NullableAnnotation;
       IsNullableStruct = type.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T;
 
-      var nonIgnoredMembers = type.GetNonIgnoredMembers();
+      var members = type.GetMembers();
 
-      for (var i = 0; i < nonIgnoredMembers.Length; i++)
+      for (var i = 0; i < members.Length; i++)
       {
-         var member = nonIgnoredMembers[i];
+         var member = members[i];
 
          if (member.IsValidateFactoryArgumentsImplementation(out var method) && method.ReturnType.SpecialType != SpecialType.System_Void)
             FactoryValidationReturnType = method.ReturnType.ToFullyQualifiedDisplayString();
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/ValueObjects/ValueObjectSourceGenerator.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/ValueObjects/ValueObjectSourceGenerator.cs
@@ -438,9 +438,9 @@ private bool IsValueObjectCandidate(TypeDeclarationSyntax typeDeclaration)
             return null;
          }
 
-         if (attributeType.TypeArguments.Length != 1)
+         if (attributeType.Arity != 1)
          {
-            Logger.LogDebug($"Expected the attribute type to have 1 type argument but found {attributeType.TypeArguments.Length.ToString()}", tds);
+            Logger.LogDebug($"Expected the attribute type to have 1 type argument but found {attributeType.Arity.ToString()}", tds);
             return null;
          }
 
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/SymbolExtensions.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/SymbolExtensions.cs
@@ -5,9 +5,9 @@ namespace Thinktecture;
 
 public static class SymbolExtensions
 {
-   public static AttributeData? FindAttribute(this ISymbol type, Func<INamedTypeSymbol, bool> predicate)
+   public static AttributeData? FindAttribute(this ISymbol symbol, Func<INamedTypeSymbol, bool> predicate)
    {
-      var attributes = type.GetAttributes();
+      var attributes = symbol.GetAttributes();
 
       if (attributes.IsDefaultOrEmpty)
          return null;
@@ -28,9 +28,14 @@ public static bool HasAttribute(this ISymbol symbol, Func<INamedTypeSymbol, bool
       return symbol.FindAttribute(predicate) is not null;
    }
 
-   public static bool IsIgnored(this ISymbol member)
+   public static bool IsIgnored(this IFieldSymbol field)
    {
-      return member.HasAttribute(static attrType => attrType.IsValueObjectMemberIgnoreAttribute());
+      return field.HasAttribute(static attrType => attrType.IsValueObjectMemberIgnoreAttribute());
+   }
+
+   public static bool IsIgnored(this IPropertySymbol property)
+   {
+      return property.HasAttribute(static attrType => attrType.IsValueObjectMemberIgnoreAttribute());
    }
 
    public static bool IsValidateFactoryArgumentsImplementation(
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/TypeSymbolExtensions.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/TypeSymbolExtensions.cs
diff --git a/test/Directory.Build.props b/test/Directory.Build.props
diff --git a/test/Thinktecture.Runtime.Extensions.SourceGenerator.Tests/AnalyzerAndCodeFixTests/TTRESG047_VariableMustBeInitializedWithNonDefaultValue.cs b/test/Thinktecture.Runtime.Extensions.SourceGenerator.Tests/AnalyzerAndCodeFixTests/TTRESG047_VariableMustBeInitializedWithNonDefaultValue.cs

Original file line number	Diff line number	Diff line change
`@@ -120,9 +120,9 @@ private bool IsUnionCandidate(TypeDeclarationSyntax typeDeclaration)`
`120`	`120`	`return null;`
`121`	`121`	`}`
`122`	`122`
`123`		`- if (attributeType.TypeArguments.Length < 2)`
	`123`	`+ if (attributeType.Arity < 2)`
`124`	`124`	`{`
`125`		`- Logger.LogDebug($"Expected the attribute type to have at least 2 type arguments but found {attributeType.TypeArguments.Length.ToString()}", tds);`
	`125`	`+ Logger.LogDebug($"Expected the attribute type to have at least 2 type arguments but found {attributeType.Arity.ToString()}", tds);`
`126`	`126`	`return null;`
`127`	`127`	`}`
`128`	`128`
`@@ -140,9 +140,9 @@ private bool IsUnionCandidate(TypeDeclarationSyntax typeDeclaration)`
`140`	`140`	`return new SourceGenContext(new SourceGenError("Could not fetch type information for code generation of a discriminated union", tds));`
`141`	`141`
`142`	`142`	`var settings = new AdHocUnionSettings(context.Attributes[0],`
`143`		`- attributeType.TypeArguments.Length,`
	`143`	`+ attributeType.Arity,`
`144`	`144`	`attributeInfo);`
`145`		`- var memberTypeStates = new AdHocUnionMemberTypeState[attributeType.TypeArguments.Length];`
	`145`	`+ var memberTypeStates = attributeType.Arity == 0 ? [] : new AdHocUnionMemberTypeState[attributeType.Arity];`
`146`	`146`
`147`	`147`	`for (var i = 0; i < attributeType.TypeArguments.Length; i++)`
`148`	`148`	`{`
Original file line number	Diff line number	Diff line change
`@@ -350,9 +350,9 @@ private bool IsEnumCandidate(TypeDeclarationSyntax typeDeclaration)`
`350`	`350`	`return null;`
`351`	`351`	`}`
`352`	`352`
`353`		`- if (attributetype.TypeArguments.Length != 1)`
	`353`	`+ if (attributetype.Arity != 1)`
`354`	`354`	`{`
`355`		`- Logger.LogDebug($"Expected the attribute type to have 1 type argument but found {attributetype.TypeArguments.Length.ToString()}", tds);`
	`355`	`+ Logger.LogDebug($"Expected the attribute type to have 1 type argument but found {attributetype.Arity.ToString()}", tds);`
`356`	`356`	`return null;`
`357`	`357`	`}`
`358`	`358`
`@@ -393,15 +393,13 @@ private bool IsEnumCandidate(TypeDeclarationSyntax typeDeclaration)`
`393`	`393`	`keyMember = settings.CreateKeyMember(keyTypedMemberState);`
`394`	`394`	`}`
`395`	`395`
`396`		`- var nonIgnoredMembers = type.GetNonIgnoredMembers();`
`397`		`- var hasCreateInvalidItemImplementation = keyMemberType is not null && settings.IsValidatable && type.HasCreateInvalidItemImplementation(nonIgnoredMembers, keyMemberType, cancellationToken);`
	`396`	`+ var hasCreateInvalidItemImplementation = keyMemberType is not null && settings.IsValidatable && type.HasCreateInvalidItemImplementation(keyMemberType, cancellationToken);`
`398`	`397`
`399`	`398`	`var derivedTypeNames = FindDerivedTypes(type);`
`400`	`399`	`var enumState = new EnumSourceGeneratorState(factory,`
`401`	`400`	`type,`
`402`	`401`	`keyMember,`
`403`	`402`	`attributeInfo.ValidationError,`
`404`		`- nonIgnoredMembers,`
`405`	`403`	`new EnumSettings(settings, attributeInfo),`
`406`	`404`	`hasCreateInvalidItemImplementation,`
`407`	`405`	`derivedTypeNames.Count > 0,`
Original file line number	Diff line number	Diff line change
`@@ -143,13 +143,13 @@ public TypedMemberState(ITypeSymbol type)`
`143`	`143`
`144`	`144`	`private static bool IsToStringNullable(ITypeSymbol type)`
`145`	`145`	`{`
`146`		`- var array = type.GetMembers();`
	`146`	`+ var array = type.GetMembers("ToString");`
`147`	`147`
`148`	`148`	`for (var i = 0; i < array.Length; i++)`
`149`	`149`	`{`
`150`	`150`	`var member = array[i];`
`151`	`151`
`152`		`- if (member is not IMethodSymbol { Name: "ToString" } toString)`
	`152`	`+ if (member is not IMethodSymbol toString)`
`153`	`153`	`continue;`
`154`	`154`
`155`	`155`	`return toString.ReturnNullableAnnotation == NullableAnnotation.Annotated;`
Original file line number	Diff line number	Diff line change
`@@ -89,9 +89,9 @@ private bool IsCandidate(SyntaxNode syntaxNode, CancellationToken cancellationTo`
`89`	`89`	`return null;`
`90`	`90`	`}`
`91`	`91`
`92`		`- if (attributeType.TypeArguments.Length != 0)`
	`92`	`+ if (attributeType.Arity != 0)`
`93`	`93`	`{`
`94`		`- Logger.LogDebug($"Expected the union attribute type to have no type arguments but found {attributeType.TypeArguments.Length.ToString()}", tds);`
	`94`	`+ Logger.LogDebug($"Expected the union attribute type to have no type arguments but found {attributeType.Arity.ToString()}", tds);`
`95`	`95`	`return null;`
`96`	`96`	`}`
`97`	`97`