add support for generic union types to funicular switch generators

.github/workflows/dotnet-ci.yml

@@ -16,7 +16,7 @@ jobs:
     - name: Setup .NET
       uses: actions/setup-dotnet@v3
       with:
-        dotnet-version: 6.0.x
+        dotnet-version: 8.0.x
     - name: Restore dependencies
       run: dotnet restore ./Source
     - name: Build

README.md

@@ -361,6 +361,8 @@ class ExampleConsumer
 }
 ```
 
+Base types of unions may also be generic types with arbitrary number of type parameters. Case types with generic arguments are not yet supported.
+
 If you like union types but don't like excessive typing in C# try the [Switchyard](https://github.com/bluehands/Switchyard) Visual Studio extension, which generates the boilerplate code for you. It plays nicely with the FunicularSwitch.Generators package.
 
 ## ExtendedEnum attribute

Source/DocSamples/ReadmeSamples.cs

@@ -110,12 +110,12 @@ static IEnumerable<string> CheckFruit(Fruit fruit)
             }
 
             var salad =
-                await ingredients
-                    .Select(ingredient =>
+                await ingredients.Select(ingredient =>
                         stock
                             .Where(fruit => fruit.Name == ingredient)
                             .FirstOk(CheckFruit, onEmpty: () => $"No {ingredient} in stock")
-                        )
+                    )
+                    .Aggregate()
                     .Bind(fruits => CutIntoPieces(fruits, cookSkillLevel))
                     .Map(Serve);
 

Source/FunicularSwitch.Generators.Common/RoslynExtensions.cs

@@ -77,10 +77,12 @@ public static bool Implements(this INamedTypeSymbol symbol, ITypeSymbol interfac
     }
 
     static readonly SymbolDisplayFormat FullTypeWithNamespaceDisplayFormat = SymbolWrapper.FullTypeWithNamespaceDisplayFormat;
+    static readonly SymbolDisplayFormat FullTypeWithNamespaceAndGenericsDisplayFormat = SymbolWrapper.FullTypeWithNamespaceAndGenericsDisplayFormat;
     static readonly SymbolDisplayFormat FullTypeDisplayFormat = new(typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypes);
 
 
     public static string FullTypeNameWithNamespace(this INamedTypeSymbol namedTypeSymbol) => namedTypeSymbol.ToDisplayString(FullTypeWithNamespaceDisplayFormat);
+    public static string FullTypeNameWithNamespaceAndGenerics(this INamedTypeSymbol namedTypeSymbol) => namedTypeSymbol.ToDisplayString(FullTypeWithNamespaceAndGenericsDisplayFormat);
     public static string FullTypeName(this INamedTypeSymbol namedTypeSymbol) => namedTypeSymbol.ToDisplayString(FullTypeDisplayFormat);
 
     public static string FullNamespace(this INamespaceSymbol namespaceSymbol) =>
@@ -99,6 +101,48 @@ public static QualifiedTypeName QualifiedName(this BaseTypeDeclarationSyntax dec
         return new(dec.Name(), typeNames);
     }
 
+    public static QualifiedTypeName QualifiedNameWithGenerics(this BaseTypeDeclarationSyntax dec)
+    {
+        var current = dec.Parent as BaseTypeDeclarationSyntax;
+        var typeNames = new Stack<string>();
+        while (current != null)
+        {
+            typeNames.Push(current.Name() + FormatTypeParameters(current.GetTypeParameterList()));
+            current = current.Parent as BaseTypeDeclarationSyntax;
+        }
+
+        return new(dec.Name() + FormatTypeParameters(dec.GetTypeParameterList()), typeNames);
+    }
+
+    public static EquatableArray<string> GetTypeParameterList(this BaseTypeDeclarationSyntax dec)
+    {
+        if (dec is not TypeDeclarationSyntax tds)
+        {
+            return [];
+        }
+
+        return tds.TypeParameterList?.Parameters.Select(tps => tps.Identifier.Text).ToImmutableArray() ?? ImmutableArray<string>.Empty;
+    }
+
+    public static string FormatTypeParameters(EquatableArray<string> typeParameters)
+    {
+        if (typeParameters.Length == 0)
+        {
+            return string.Empty;
+        }
+
+        return "<" + string.Join(", ", typeParameters) + ">";
+    }
+
+    public static string FormatTypeParameterForFileName(EquatableArray<string> typeParameters)
+    {
+        if (typeParameters.Length == 0)
+        {
+            return string.Empty;
+        }
+
+        return "Of" + string.Join("_", typeParameters);
+    }
 
     public static string Name(this BaseTypeDeclarationSyntax declaration) => declaration.Identifier.ToString();
 

Source/FunicularSwitch.Generators.Common/SymbolWrapper.cs

@@ -5,6 +5,7 @@ namespace FunicularSwitch.Generators.Common;
 public static class SymbolWrapper
 {
     internal static readonly SymbolDisplayFormat FullTypeWithNamespaceDisplayFormat = new(typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces);
+    internal static readonly SymbolDisplayFormat FullTypeWithNamespaceAndGenericsDisplayFormat = new(typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces, genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters);
 
     public static SymbolWrapper<T> Create<T>(T symbol) where T : ISymbol => new(symbol);
 }

Source/FunicularSwitch.Generators.FluentAssertions.Templates/MyAssertionExtensions_UnionType.cs

@@ -4,6 +4,6 @@ namespace FunicularSwitch.Generators.FluentAssertions.Templates
 {
     internal static class MyAssertionExtensions_UnionType
     {
-        public static MyAssertions_UnionType Should(this MyUnionType unionType) => new(unionType);
+        public static MyAssertions_UnionType Should<TTypeParameters>(this MyUnionType unionType) => new(unionType);
     }
 }

Source/FunicularSwitch.Generators.FluentAssertions.Templates/MyUnionTypeAssertions_DerivedUnionType.cs

@@ -13,7 +13,7 @@ public AndWhichConstraint<MyAssertions_UnionType, MyDerivedUnionType> BeFriendly
             Execute.Assertion
                 .ForCondition(this.Subject is MyDerivedUnionType)
                 .BecauseOf(because, becauseArgs)
-                .FailWith("Expected {context} to be Error with MyDerivedErrorType MyErrorType{reason}, but found {0}",
+                .FailWith("Expected {context} to be MyDerivedUnionType{reason}, but found {0}",
                     this.Subject);
 
             return new(this, (this.Subject as MyDerivedUnionType)!);

Source/FunicularSwitch.Generators.FluentAssertions/FluentAssertionMethods/Generator.cs

@@ -1,4 +1,6 @@
-using FunicularSwitch.Generators.Common;
+using System.Collections.Immutable;
+using CommunityToolkit.Mvvm.SourceGenerators.Helpers;
+using FunicularSwitch.Generators.Common;
 using Microsoft.CodeAnalysis;
 
 namespace FunicularSwitch.Generators.FluentAssertions.FluentAssertionMethods;
@@ -14,6 +16,7 @@ internal static class Generator
     private const string TemplateResultAssertionExtensions = "MyAssertionExtensions_Result";
     private const string TemplateUnionTypeAssertionsTypeName = "MyAssertions_UnionType";
     private const string TemplateUnionTypeAssertionExtensions = "MyAssertionExtensions_UnionType";
+    private const string TemplateUnionTypeTypeParameterList = "<TTypeParameters>";
     private const string TemplateFriendlyDerivedUnionTypeName = "FriendlyDerivedUnionTypeName";
     private const string TemplateAdditionalUsingDirectives = "//additional using directives";
 
@@ -64,19 +67,25 @@ string Replace(string code, params string[] additionalNamespaces)
     {
         var unionTypeFullName = unionTypeSchema.UnionTypeBaseType.FullTypeName().Replace('.', '_');
         var unionTypeFullNameWithNamespace = unionTypeSchema.UnionTypeBaseType.FullTypeNameWithNamespace();
+        var unionTypeFullNameWithNamespaceAndGenerics = unionTypeSchema.UnionTypeBaseType.FullTypeNameWithNamespaceAndGenerics();
+        EquatableArray<string> typeParameters = unionTypeSchema.UnionTypeBaseType.TypeParameters
+            .Select(t => t.Name).ToImmutableArray();
         var unionTypeNamespace = unionTypeSchema.UnionTypeBaseType.GetFullNamespace();
+        var typeParametersText = RoslynExtensions.FormatTypeParameters(typeParameters);
 
-        var generateFileHint = $"{unionTypeFullNameWithNamespace}";
+        var generateFileHint = $"{unionTypeFullNameWithNamespace}{RoslynExtensions.FormatTypeParameterForFileName(typeParameters)}";
 
         //var generatorRuns = RunCount.Increase(unionTypeSchema.UnionTypeBaseType.FullTypeNameWithNamespace());
 
         string Replace(string code, params string[] additionalNamespaces)
         {
             code = code
                 .Replace($"namespace {TemplateNamespace}", $"namespace {unionTypeNamespace}")
-                .Replace(TemplateUnionTypeName, unionTypeFullNameWithNamespace)
-                .Replace(TemplateUnionTypeAssertionsTypeName, $"{unionTypeFullName}Assertions")
+                .Replace(TemplateUnionTypeName, unionTypeFullNameWithNamespaceAndGenerics)
+                .Replace($"public {TemplateUnionTypeAssertionsTypeName}(", $"public {unionTypeFullName}Assertions(")
+                .Replace(TemplateUnionTypeAssertionsTypeName, $"{unionTypeFullName}Assertions{typeParametersText}")
                 .Replace(TemplateUnionTypeAssertionExtensions, $"{unionTypeFullName}FluentAssertionExtensions")
+                .Replace(TemplateUnionTypeTypeParameterList, typeParametersText)
                 .Replace(
                     TemplateAdditionalUsingDirectives,
                     additionalNamespaces
@@ -99,7 +108,7 @@ string Replace(string code, params string[] additionalNamespaces)
 
         foreach (var derivedType in unionTypeSchema.DerivedTypes)
         {
-            var derivedTypeFullNameWithNamespace = derivedType.FullTypeNameWithNamespace();
+            var derivedTypeFullNameWithNamespace = derivedType.FullTypeNameWithNamespaceAndGenerics();
             yield return (
                 $"{generateFileHint}_Derived_{derivedType.Name}Assertions.g.cs",
                 Replace(Templates.GenerateFluentAssertionsForTemplates.MyDerivedUnionTypeAssertions)

Source/FunicularSwitch.Generators.FluentAssertions/FluentAssertionMethods/ResultTypeSchema.cs

@@ -2,16 +2,9 @@
 
 namespace FunicularSwitch.Generators.FluentAssertions.FluentAssertionMethods;
 
-public class ResultTypeSchema
+public record ResultTypeSchema(
+    INamedTypeSymbol ResultType,
+    INamedTypeSymbol? ErrorType)
 {
-    public INamedTypeSymbol ResultType { get; }
-    public INamedTypeSymbol? ErrorType { get; }
-
-    public ResultTypeSchema(INamedTypeSymbol resultType, INamedTypeSymbol? errorType)
-    {
-        ResultType = resultType;
-        ErrorType = errorType;
-    }
-
     public override string ToString() => $"{nameof(ResultType)}: {ResultType}, {nameof(ErrorType)}: {ErrorType}";
 }

Source/FunicularSwitch.Generators.FluentAssertions/FluentAssertionMethods/UnionTypeSchema.cs

@@ -2,14 +2,13 @@
 
 namespace FunicularSwitch.Generators.FluentAssertions.FluentAssertionMethods;
 
-public class UnionTypeSchema
+public record UnionTypeSchema(
+    INamedTypeSymbol UnionTypeBaseType,
+    IEnumerable<INamedTypeSymbol> DerivedTypes)
 {
-    public UnionTypeSchema(INamedTypeSymbol unionTypeBaseType, IEnumerable<INamedTypeSymbol> derivedTypes)
+    public override string ToString()
     {
-        UnionTypeBaseType = unionTypeBaseType;
-        DerivedTypes = derivedTypes.ToList();
+        var derivedTypes = string.Join(", ", DerivedTypes.Select(d => d.ToString()));
+        return $"{nameof(UnionTypeBaseType)}: {UnionTypeBaseType}, {nameof(DerivedTypes)}, {derivedTypes}";
     }
-
-    public INamedTypeSymbol UnionTypeBaseType { get; }
-    public IReadOnlyList<INamedTypeSymbol> DerivedTypes { get; }
 }

Source/FunicularSwitch.Generators.FluentAssertions/FunicularSwitch.Generators.FluentAssertions.csproj

@@ -23,7 +23,7 @@
 
 		<!--#region adapt versions here-->
 		<MajorVersion>1</MajorVersion>
-		<MinorAndPatchVersion>2.2</MinorAndPatchVersion>
+		<MinorAndPatchVersion>3.0</MinorAndPatchVersion>
 		<!--#endregion-->
 
 		<AssemblyVersion>$(MajorVersion).0.0</AssemblyVersion>

Source/FunicularSwitch.Generators/EnumType/Generator.cs

@@ -1,4 +1,5 @@
-using FunicularSwitch.Generators.Common;
+using System.Collections.Immutable;
+using FunicularSwitch.Generators.Common;
 using FunicularSwitch.Generators.Generation;
 using Microsoft.CodeAnalysis;
 
@@ -55,7 +56,7 @@ void BlankLine()
         }
 
         builder.WriteLine("#pragma warning restore 1591");
-        return (enumTypeSchema.FullTypeName.ToMatchExtensionFilename(), builder.ToString());
+        return (enumTypeSchema.FullTypeName.ToMatchExtensionFilename(ImmutableArray<string>.Empty), builder.ToString());
     }
 
     static void GenerateMatchMethod(CSharpBuilder builder, EnumTypeSchema enumTypeSchema, string t)

Source/FunicularSwitch.Generators/FunicularSwitch.Generators.csproj

@@ -23,7 +23,7 @@
 
 		<!--#region adapt versions here-->
 		<MajorVersion>4</MajorVersion>
-		<MinorAndPatchVersion>1.3</MinorAndPatchVersion>
+		<MinorAndPatchVersion>2.0</MinorAndPatchVersion>
 		<!--#endregion-->
 
 		<AssemblyVersion>$(MajorVersion).0.0</AssemblyVersion>

Source/FunicularSwitch.Generators/Generation/Indent.cs

@@ -1,4 +1,5 @@
-using FunicularSwitch.Generators.Common;
+using CommunityToolkit.Mvvm.SourceGenerators.Helpers;
+using FunicularSwitch.Generators.Common;
 
 namespace FunicularSwitch.Generators.Generation;
 
@@ -242,5 +243,7 @@ public static string TrimBaseTypeName(this string value, string baseTypeName)
         return value;
     }
 
-    public static string ToMatchExtensionFilename(this string fullTypeName) => $"{fullTypeName.Replace(".", "")}MatchExtension.g.cs";
+    public static string ToMatchExtensionFilename(this string fullTypeName, EquatableArray<string> typeParameters) => $"{fullTypeName.Replace(".", "")}{RoslynExtensions.FormatTypeParameterForFileName(typeParameters)}MatchExtension.g.cs";
+
+
 }