add configuration of param name generation of nested regular unions

Author: PawelGerr

.claude/CLAUDE-ATTRIBUTES.md

@@ -0,0 +1,21 @@
+namespace Thinktecture.Unions;
+
+/// <summary>
+/// Example demonstrating Simple parameter name generation for nested unions.
+/// This generates shorter parameter names (notFound, unauthorized) instead of
+/// the default longer names (failureNotFound, failureUnauthorized).
+/// </summary>
+[Union(NestedUnionParameterNames = NestedUnionParameterNameGeneration.Simple)]
+[UnionSwitchMapOverload(StopAt = [typeof(Failure)])]
+public partial class ApiResponseWithSimpleParameterNames
+{
+   public sealed class Success : ApiResponseWithSimpleParameterNames;
+
+   [Union]
+   public abstract partial class Failure : ApiResponseWithSimpleParameterNames
+   {
+      public sealed class NotFound : Failure;
+
+      public sealed class Unauthorized : Failure;
+   }
+}

docs

@@ -305,8 +305,18 @@ private static void DemoForNestedUnionsAndSwitchMapOverloads(ILogger logger)
 
                          """);
 
+      logger.Information("--- Default Parameter Names ---");
+
       var apiResponse = new ApiResponse.Failure.Unauthorized();
 
+      // With default parameter naming, nested types include their parent union name
+      apiResponse.Switch(
+         success: success => logger.Information("[Switch] Success"),
+         failureNotFound: notFound => logger.Information("[Switch] Not Found"),
+         failureUnauthorized: unauthorized => logger.Information("[Switch] Unauthorized")
+      );
+
+      // Non-exhaustive overload (stopped at Failure level)
       apiResponse.Switch(
          success: success => logger.Information("[Switch] Success"),
          failure: HandleFailure);
@@ -318,5 +328,29 @@ void HandleFailure(ApiResponse.Failure failure)
             unauthorized: unauthorized => logger.Information("[Switch] Unauthorized")
          );
       }
+
+      logger.Information("--- Simple Parameter Names ---");
+
+      var apiResponseSimple = new ApiResponseWithSimpleParameterNames.Failure.NotFound();
+
+      // With simple parameter naming, nested types use only their own name
+      apiResponseSimple.Switch(
+         success: success => logger.Information("[Switch] Success"),
+         notFound: notFound => logger.Information("[Switch] Not Found"),        // Simple name
+         unauthorized: unauthorized => logger.Information("[Switch] Unauthorized")  // Simple name
+      );
+
+      // Non-exhaustive overload (stopped at Failure level)
+      apiResponseSimple.Switch(
+         success: success => logger.Information("[Switch] Success"),
+         failure: HandleFailureSimple);
+
+      void HandleFailureSimple(ApiResponseWithSimpleParameterNames.Failure failure)
+      {
+         failure.Switch(
+            notFound: notFound => logger.Information("[Switch] Not Found"),
+            unauthorized: unauthorized => logger.Information("[Switch] Unauthorized")
+         );
+      }
    }
 }

samples/Basic.Samples/Unions/ApiResponseWithSimpleParameterNames.cs

@@ -114,6 +114,7 @@ public static class Properties
          public const string SWITCH_MAP_STATE_PARAMETER_NAME = "SwitchMapStateParameterName";
          public const string SWITCH_METHODS = "SwitchMethods";
          public const string TRY_CREATE_FACTORY_METHOD_NAME = "TryCreateFactoryMethodName";
+         public const string NESTED_UNION_PARAMETER_NAMES = "NestedUnionParameterNames";
          public const string UNSAFE_CONVERSION_TO_KEY_MEMBER_TYPE = "UnsafeConversionToKeyMemberType";
          public const string USE_FOR_MODEL_BINDING = "UseForModelBinding";
          public const string USE_FOR_SERIALIZATION = "UseForSerialization";

samples/Basic.Samples/Unions/DiscriminatedUnionsDemos.cs

@@ -0,0 +1,7 @@
+namespace Thinktecture.CodeAnalysis;
+
+public enum NestedUnionParameterNameGeneration
+{
+   Default = 0,
+   Simple = 1
+}

src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/Constants.cs

@@ -82,10 +82,9 @@ private TypeMember MakeTypeMember(
       TypeMember? baseType,
       StringBuilder sb)
    {
-      // Skip all containing types of the union itself + the union's own type
-      // This ensures parameter names are just the member name (e.g., "success")
-      // unless the member is nested in another union within this union
-      var skipLevels = _state.ContainingTypes.Length + 1;
+      var skipLevels = _state.Settings.NestedUnionParameterNames == NestedUnionParameterNameGeneration.Simple
+                          ? typeMember.ContainingTypes.Length
+                          : _state.ContainingTypes.Length + 1;
 
       var argName = typeMember.ContainingTypes
                               .MakeFullyQualifiedArgumentName(typeMember.Name, skipLevels, sb);

src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/NestedUnionParameterNameGeneration.cs

@@ -7,6 +7,7 @@ public sealed class RegularUnionSettings : IEquatable<RegularUnionSettings>, IHa
    public ConversionOperatorsGeneration ConversionFromValue { get; }
    public string SwitchMapStateParameterName { get; }
    public ImmutableArray<RegularUnionSwitchMapOverload> SwitchMapOverloads { get; }
+   public NestedUnionParameterNameGeneration NestedUnionParameterNames { get; }
 
    public RegularUnionSettings(
       AttributeData attribute,
@@ -17,6 +18,7 @@ public RegularUnionSettings(
       ConversionFromValue = attribute.FindConversionFromValue() ?? ConversionOperatorsGeneration.Implicit;
       SwitchMapStateParameterName = attribute.FindSwitchMapStateParameterName();
       SwitchMapOverloads = switchMapOverloads;
+      NestedUnionParameterNames = attribute.FindNestedUnionParameterNameGeneration();
    }
 
    public override bool Equals(object? obj)
@@ -36,6 +38,7 @@ public bool Equals(RegularUnionSettings? other)
              && MapMethods == other.MapMethods
              && ConversionFromValue == other.ConversionFromValue
              && SwitchMapStateParameterName == other.SwitchMapStateParameterName
+             && NestedUnionParameterNames == other.NestedUnionParameterNames
              && SwitchMapOverloads.SequenceEqual(other.SwitchMapOverloads);
    }
 
@@ -47,6 +50,7 @@ public override int GetHashCode()
          hashCode = (hashCode * 397) ^ (int)MapMethods;
          hashCode = (hashCode * 397) ^ (int)ConversionFromValue;
          hashCode = (hashCode * 397) ^ SwitchMapStateParameterName.GetHashCode();
+         hashCode = (hashCode * 397) ^ (int)NestedUnionParameterNames;
          hashCode = (hashCode * 397) ^ SwitchMapOverloads.ComputeHashCode();
 
          return hashCode;

src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/RegularUnions/RegularUnionCodeGenerator.cs

@@ -235,6 +235,13 @@ public static string FindSwitchMapStateParameterName(this AttributeData attribut
       return GetStringParameterValue(attributeData, Constants.Attributes.Properties.SWITCH_MAP_STATE_PARAMETER_NAME) ?? "state";
    }
 
+   public static NestedUnionParameterNameGeneration FindNestedUnionParameterNameGeneration(
+      this AttributeData attribute)
+   {
+      return GetEnumParameterValue<NestedUnionParameterNameGeneration>(attribute, Constants.Attributes.Properties.NESTED_UNION_PARAMETER_NAMES)
+             ?? NestedUnionParameterNameGeneration.Default;
+   }
+
    public static UnionConstructorAccessModifier FindUnionConstructorAccessModifier(this AttributeData attributeData)
    {
       return GetEnumParameterValue<UnionConstructorAccessModifier>(attributeData, Constants.Attributes.Properties.CONSTRUCTOR_ACCESS_MODIFIER)

src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/RegularUnions/RegularUnionSettings.cs

@@ -0,0 +1,44 @@
+namespace Thinktecture;
+
+/// <summary>
+/// Controls how parameter names are generated in Switch/Map methods for nested Regular Union types.
+/// </summary>
+public enum NestedUnionParameterNameGeneration
+{
+   /// <summary>
+   /// Default naming strategy: Includes intermediate type names in the parameter name.
+   /// For example, a nested type <c>Failure.NotFound</c> generates the parameter name <c>failureNotFound</c>.
+   /// This ensures uniqueness when multiple nested unions exist but can result in longer parameter names.
+   /// </summary>
+   Default = 0,
+
+   /// <summary>
+   /// Simple naming strategy: Uses only the final type name as the parameter name.
+   /// For example, a nested type <c>Failure.NotFound</c> generates the parameter name <c>notFound</c>.
+   /// <para>
+   /// <b>WARNING:</b> This can cause parameter name collisions if multiple nested unions have types
+   /// with the same name. The C# compiler will report duplicate parameter errors if conflicts occur.
+   /// </para>
+   /// <example>
+   /// This will cause a compilation error:
+   /// <code>
+   /// [Union(NestedUnionParameterNames = NestedUnionParameterNameGeneration.Simple)]
+   /// public partial class Response
+   /// {
+   ///    [Union]
+   ///    public abstract partial class Success : Response
+   ///    {
+   ///       public sealed class Status : Success;  // Parameter: status
+   ///    }
+   ///
+   ///    [Union]
+   ///    public abstract partial class Failure : Response
+   ///    {
+   ///       public sealed class Status : Failure;  // Parameter: status (CONFLICT!)
+   ///    }
+   /// }
+   /// </code>
+   /// </example>
+   /// </summary>
+   Simple = 1
+}