Adjustments regarding "SkipEqualityComparison"

* Removed from `UnionAttribute` because it has no effect on regular unions
* Added test for non-generic ad hoc union and keyed value object
* Added test classes using the new attribute (smoke test)
* Updated docs

Author: PawelGerr

CLAUDE.md

@@ -22,7 +22,7 @@ This is a .NET library providing **Smart Enums**, **Value Objects**, and **Discr
 
 ### Core Components
 - **`src/Thinktecture.Runtime.Extensions`**: Core library with base interfaces, attributes, and runtime helpers
-  - Attributes: `SmartEnumAttribute<TKey>`, `SmartEnumAttribute`, `ValueObjectAttribute<TKey>`, `ComplexValueObjectAttribute`, `UnionAttribute<T1,T2,...>` (up to 5 type parameters), `UnionAttribute`, `ObjectFactoryAttribute<T>`
+  - Attributes: `SmartEnumAttribute<TKey>`, `SmartEnumAttribute`, `ValueObjectAttribute<TKey>`, `ComplexValueObjectAttribute`, `UnionAttribute<T1,T2,...>` (up to 5 type parameters), `AdHocUnionAttribute` (non-generic alternative to UnionAttribute), `UnionAttribute`, `ObjectFactoryAttribute<T>`
   - Additional attributes: `KeyMemberEqualityComparerAttribute`, `KeyMemberComparerAttribute`, `MemberEqualityComparerAttribute`, `IgnoreMemberAttribute`, `ValidationErrorAttribute`, `UseDelegateFromConstructorAttribute`, `UnionSwitchMapOverloadAttribute`
   - Key interfaces: `ISmartEnum<TKey>`, `IEnum`, `IKeyedObject<TKey>`, `IKeyedValueObject<TKey>`, `IComplexValueObject`, `IValidationError`, `IObjectFactory<T>`
   - Utility types: `ValidationError`, `ComparerAccessors`, collection helpers (EmptyDictionary, EmptyLookup, SingleItemReadOnlyDictionary, etc.)
@@ -53,7 +53,8 @@ The `Thinktecture.Runtime.Extensions.SourceGenerator` project contains multiple
    - Supports arithmetic operators (`+`, `-`, `*`, `/`) when configured
    - Integrates with serializers (JSON, MessagePack, Newtonsoft.Json)
 
-3. **`AdHocUnionSourceGenerator`**: Generates code for ad-hoc unions annotated with `[Union<T1, T2, ...>]` (up to 5 types)
+3. **`AdHocUnionSourceGenerator`**: Generates code for ad-hoc unions annotated with `[Union<T1, T2, ...>]` or `[AdHocUnion(typeof(T1), typeof(T2), ...)]` (up to 5 types)
+   - Supports both generic and non-generic attribute syntaxes (identical functionality)
    - Creates implicit conversion operators for each union member type
    - Generates exhaustive `Switch`/`Map` methods for pattern matching
    - Provides type-safe value access with `IsT1`, `AsT1` properties and methods
@@ -147,16 +148,22 @@ The `Thinktecture.Runtime.Extensions.SourceGenerator` project contains multiple
 **Common settings**:
 - `SkipFactoryMethods`: Skip generation of `Create`, `TryCreate`, `Validate`
 - `SkipIParsable`, `SkipIComparable`, `SkipIFormattable`: Skip interface implementations
+- `SkipEqualityComparison`: Skip generation of equality members (`Equals`, `GetHashCode`, `==`, `!=`, `IEquatable<T>`) - also sets `ComparisonOperators` and `EqualityComparisonOperators` to `None`
 - Validation: Implement `ValidateFactoryArguments` (preferred) or `ValidateConstructorArguments`
 
 #### 3. Discriminated Unions
-**Ad-hoc Unions**: `[Union<T1, T2>]` through `[Union<T1, T2, T3, T4, T5>]`
+**Ad-hoc Unions**: `[Union<T1, T2>]` through `[Union<T1, T2, T3, T4, T5>]` OR `[AdHocUnion(typeof(T1), typeof(T2), ...)]`
 - Simple combination of 2-5 types without inheritance
+- Two syntaxes available:
+  - **Generic** (recommended): `[Union<string, int>]` - simpler syntax for most cases
+  - **Non-generic**: `[AdHocUnion(typeof(string), typeof(int))]` - use when generic attribute limitations are hit (e.g., nullable reference types in generic collections like `List<string?>`, or other C# generic attribute constraints)
+- Both syntaxes generate identical functionality and support the same customization options
 - Generates implicit conversion operators from each type to union (configurable via `ConversionFromValue`)
 - Type checking: `IsT1`, `IsT2`, etc. properties
 - Value access: `AsT1`, `AsT2`, etc. properties (throws if wrong type)
 - Configurable member names: `T1Name`, `T2Name`, etc.
 - Nullable reference types: `T1IsNullableReferenceType`, `T2IsNullableReferenceType`, etc.
+- `SkipEqualityComparison`: Skip generation of equality members (`Equals`, `GetHashCode`, `==`, `!=`, `IEquatable<T>`) for ad-hoc unions only
 - Supports `Switch`/`Map` methods for exhaustive pattern matching
 
 **Regular (Inheritance-based) Unions**: `[Union]`

docs

@@ -28,12 +28,6 @@ public sealed class UnionAttribute : Attribute
    /// </summary>
    public string? SwitchMapStateParameterName { get; set; }
 
-   /// <summary>
-   /// Indication whether the generator should skip the implementation of <c>IEquatable{T}</c> and any comparison operators.
-   /// This includes the <c>Equals</c> and <c>GetHashCode</c> methods.
-   /// </summary>
-   public bool SkipEqualityComparison { get; set; }
-
    /// <summary>
    /// Initializes a new instance of <see cref="UnionAttribute"/>.
    /// </summary>

src/Thinktecture.Runtime.Extensions/UnionAttribute.cs

@@ -5,8 +5,6 @@ namespace Thinktecture.Tests
 {
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("ThinktectureRuntimeExtensionsAnalyzer", "TTRESG1000:Internal Thinktecture.Runtime.Extensions API usage")]
    sealed partial class TestUnion :
-      global::System.IEquatable<global::Thinktecture.Tests.TestUnion>,
-      global::System.Numerics.IEqualityOperators<global::Thinktecture.Tests.TestUnion, global::Thinktecture.Tests.TestUnion, bool>,
       global::Thinktecture.IDisallowDefaultValue,
       global::Thinktecture.Internal.IMetadataOwner
    {
@@ -456,51 +454,6 @@ namespace Thinktecture.Tests
          return obj.AsNullableOfInt32;
       }
 
-      /// <summary>
-      /// Compares two instances of <see cref="TestUnion"/>.
-      /// </summary>
-      /// <param name="obj">Instance to compare.</param>
-      /// <param name="other">Another instance to compare.</param>
-      /// <returns><c>true</c> if objects are equal; otherwise <c>false</c>.</returns>
-      public static bool operator ==(global::Thinktecture.Tests.TestUnion? obj, global::Thinktecture.Tests.TestUnion? other)
-      {
-         if (obj is null)
-            return other is null;
-
-         return obj.Equals(other);
-      }
-
-      /// <summary>
-      /// Compares two instances of <see cref="TestUnion"/>.
-      /// </summary>
-      /// <param name="obj">Instance to compare.</param>
-      /// <param name="other">Another instance to compare.</param>
-      /// <returns><c>false</c> if objects are equal; otherwise <c>true</c>.</returns>
-      public static bool operator !=(global::Thinktecture.Tests.TestUnion? obj, global::Thinktecture.Tests.TestUnion? other)
-      {
-         return !(obj == other);
-      }
-
-      /// <inheritdoc />
-      public override bool Equals(object? other)
-      {
-         return other is global::Thinktecture.Tests.TestUnion obj && Equals(obj);
-      }
-
-      /// <inheritdoc />
-      public override int GetHashCode()
-      {
-         return this._valueIndex switch
-         {
-            1 => global::System.HashCode.Combine(global::Thinktecture.Tests.TestUnion._typeHashCode, this._int32.GetHashCode()),
-            2 => global::System.HashCode.Combine(global::Thinktecture.Tests.TestUnion._typeHashCode, ((string?)this._obj)?.GetHashCode(global::System.StringComparison.OrdinalIgnoreCase) ?? 0),
-            3 => global::System.HashCode.Combine(global::Thinktecture.Tests.TestUnion._typeHashCode, ((global::System.Collections.Generic.List<int>?)this._obj)?.GetHashCode() ?? 0),
-            4 => global::System.HashCode.Combine(global::Thinktecture.Tests.TestUnion._typeHashCode, this._boolean.GetHashCode()),
-            5 => global::System.HashCode.Combine(global::Thinktecture.Tests.TestUnion._typeHashCode, this._nullableOfInt32.GetHashCode()),
-            _ => throw new global::System.IndexOutOfRangeException($"Unexpected value index '{this._valueIndex}'.")
-         };
-      }
-
       /// <inheritdoc />
       public override string? ToString()
       {

…ethod_with_SkipEqualsMethod.verified.txt …generic_AdHocUnionAttribute.verified.txttest/Thinktecture.Runtime.Extensions.SourceGenerator.Tests/SourceGeneratorTests/AdHocUnionSourceGeneratorTests.Should_skip_equals_method_with_SkipEqualsMethod.verified.txt renamed to test/Thinktecture.Runtime.Extensions.SourceGenerator.Tests/SourceGeneratorTests/AdHocUnionSourceGeneratorTests.Should_skip_equals_method_with_SkipEqualityComparison_using_non_generic_AdHocUnionAttribute.verified.txt test/Thinktecture.Runtime.Extensions.SourceGenerator.Tests/SourceGeneratorTests/AdHocUnionSourceGeneratorTests.Should_skip_equals_method_with_SkipEqualsMethod.verified.txt renamed to test/Thinktecture.Runtime.Extensions.SourceGenerator.Tests/SourceGeneratorTests/AdHocUnionSourceGeneratorTests.Should_skip_equals_method_with_SkipEqualityComparison_using_non_generic_AdHocUnionAttribute.verified.txt

@@ -551,4 +551,22 @@ public partial class TestUnion;
 
       await VerifyAsync(outputs, "Thinktecture.Tests.TestUnion.AdHocUnion.g.cs");
    }
+
+   [Fact]
+   public async Task Should_skip_equals_method_with_SkipEqualityComparison_using_non_generic_AdHocUnionAttribute()
+   {
+      var source = """
+         using System;
+         using System.Collections.Generic;
+
+         namespace Thinktecture.Tests
+         {
+         	[AdHocUnion(typeof(int), typeof(string), typeof(List<int>), typeof(bool), typeof(int?), SkipEqualityComparison = true)]
+            public partial class TestUnion;
+         }
+         """;
+      var outputs = GetGeneratedOutputs<AdHocUnionSourceGenerator>(source, typeof(UnionAttribute<,>).Assembly);
+
+      await VerifyAsync(outputs, "Thinktecture.Tests.TestUnion.AdHocUnion.g.cs");
+   }
 }