Number of generics is part of the type hint name.

PawelGerr · PawelGerr · commit 604425ad4c9e · 2024-11-21T09:24:57.000+01:00
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/AdHocUnions/AdHocUnionSourceGenState.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/AdHocUnions/AdHocUnionSourceGenState.cs
@@ -5,6 +5,7 @@ public sealed class AdHocUnionSourceGenState : ITypeInformation, IEquatable<AdHo
    public string? Namespace { get; }
    public string Name { get; }
    public IReadOnlyList<ContainingTypeState> ContainingTypes { get; }
+
    public string TypeFullyQualified { get; }
    public string TypeMinimallyQualified { get; }
    public bool IsReferenceType { get; }
@@ -14,6 +15,7 @@ public sealed class AdHocUnionSourceGenState : ITypeInformation, IEquatable<AdHo
    public bool IsEqualWithReferenceEquality => false;
 
    public IReadOnlyList<AdHocUnionMemberTypeState> MemberTypes { get; }
+   public IReadOnlyList<string> GenericsFullyQualified => [];
    public AdHocUnionSettings Settings { get; }
 
    public AdHocUnionSourceGenState(
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/INamespaceAndName.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/INamespaceAndName.cs
@@ -5,4 +5,5 @@ public interface INamespaceAndName
    string? Namespace { get; }
    string Name { get; }
    IReadOnlyList<ContainingTypeState> ContainingTypes { get; }
+   IReadOnlyList<string> GenericsFullyQualified { get; }
 }
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/KeyedSerializerGeneratorState.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/KeyedSerializerGeneratorState.cs
@@ -9,6 +9,7 @@ namespace Thinktecture.CodeAnalysis;
    public string? Namespace => Type.Namespace;
    public IReadOnlyList<ContainingTypeState> ContainingTypes => Type.ContainingTypes;
    public string Name => Type.Name;
+   public IReadOnlyList<string> GenericsFullyQualified => [];
 
    public KeyedSerializerGeneratorState(
       ITypeInformation type,
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/SmartEnums/EnumSourceGeneratorState.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/SmartEnums/EnumSourceGeneratorState.cs
@@ -8,6 +8,7 @@ public sealed class EnumSourceGeneratorState : ITypeInformation, IEquatable<Enum
    public string TypeMinimallyQualified { get; }
    public bool IsEqualWithReferenceEquality => !Settings.IsValidatable;
    public IReadOnlyList<ContainingTypeState> ContainingTypes { get; }
+   public IReadOnlyList<string> GenericsFullyQualified => [];
 
    public KeyMemberState? KeyMember { get; }
    public ValidationErrorState ValidationError { get; }
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/SmartEnums/SmartEnumDerivedTypes.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/SmartEnums/SmartEnumDerivedTypes.cs
@@ -8,6 +8,7 @@ public sealed class SmartEnumDerivedTypes : INamespaceAndName, ITypeFullyQualifi
    public bool IsReferenceType { get; }
    public IReadOnlyList<ContainingTypeState> ContainingTypes { get; }
    public IReadOnlyList<string> DerivedTypesFullyQualified { get; }
+   public IReadOnlyList<string> GenericsFullyQualified => [];
 
    public SmartEnumDerivedTypes(
       string? ns,
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/ThinktectureSourceGeneratorBase.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/ThinktectureSourceGeneratorBase.cs
@@ -157,6 +157,7 @@ protected void InitializeFormattableCodeGenerator(
                                                                                                state.Left.Type.Namespace,
                                                                                                state.Left.Type.ContainingTypes,
                                                                                                state.Left.Type.Name,
+                                                                                               state.Left.Type.GenericsFullyQualified.Count,
                                                                                                new InterfaceCodeGeneratorState(state.Left.Type, state.Left.KeyMember, state.Left.CreateFactoryMethodName),
                                                                                                state.Right,
                                                                                                InterfaceCodeGeneratorFactory.Formattable));
@@ -180,6 +181,7 @@ protected void InitializeComparableCodeGenerator(
                                                                                               state.Left.Type.Namespace,
                                                                                               state.Left.Type.ContainingTypes,
                                                                                               state.Left.Type.Name,
+                                                                                              state.Left.Type.GenericsFullyQualified.Count,
                                                                                               new InterfaceCodeGeneratorState(state.Left.Type, state.Left.KeyMember, state.Left.CreateFactoryMethodName),
                                                                                               state.Right,
                                                                                               InterfaceCodeGeneratorFactory.Comparable(state.Left.ComparerAccessor)));
@@ -203,6 +205,7 @@ protected void InitializeParsableCodeGenerator(
                                                                                             state.Left.Type.Namespace,
                                                                                             state.Left.Type.ContainingTypes,
                                                                                             state.Left.Type.Name,
+                                                                                            state.Left.Type.GenericsFullyQualified.Count,
                                                                                             state.Left,
                                                                                             state.Right,
                                                                                             InterfaceCodeGeneratorFactory.Parsable(state.Left.IsEnum, state.Left.IsValidatableEnum)));
@@ -239,6 +242,7 @@ protected void InitializeComparisonOperatorsCodeGenerator(
                                                                                state.Type.Namespace,
                                                                                state.Type.ContainingTypes,
                                                                                state.Type.Name,
+                                                                               state.Type.GenericsFullyQualified.Count,
                                                                                new InterfaceCodeGeneratorState(state.Type, state.KeyMember, state.CreateFactoryMethodName),
                                                                                tuple.Right,
                                                                                InterfaceCodeGeneratorFactory.Create(generator));
@@ -266,6 +270,7 @@ protected void InitializeEqualityComparisonOperatorsCodeGenerator(
                                                                                   tuple.Left.Type.Namespace,
                                                                                   tuple.Left.Type.ContainingTypes,
                                                                                   tuple.Left.Type.Name,
+                                                                                  tuple.Left.Type.GenericsFullyQualified.Count,
                                                                                   tuple.Left,
                                                                                   tuple.Right,
                                                                                   generator);
@@ -303,6 +308,7 @@ protected void InitializeOperatorsCodeGenerator(
                                                    state.Type.Namespace,
                                                    state.Type.ContainingTypes,
                                                    state.Type.Name,
+                                                   state.Type.GenericsFullyQualified.Count,
                                                    new InterfaceCodeGeneratorState(state.Type, state.KeyMember, state.CreateFactoryMethodName),
                                                    tuple.Right,
                                                    InterfaceCodeGeneratorFactory.Create(generator));
@@ -336,14 +342,15 @@ private void GenerateCode<TState>(
       StringBuilder stringBuilder)
       where TState : INamespaceAndName, IEquatable<TState>
    {
-      GenerateCode(context, state.Namespace, state.ContainingTypes, state.Name, state, options, generatorFactory, stringBuilder);
+      GenerateCode(context, state.Namespace, state.ContainingTypes, state.Name, state.GenericsFullyQualified.Count, state, options, generatorFactory, stringBuilder);
    }
 
    private void GenerateCode<TState>(
       SourceProductionContext context,
       string? ns,
       IReadOnlyList<ContainingTypeState> containingTypes,
       string name,
+      int numberOfGenerics,
       TState state,
       GeneratorOptions options,
       ICodeGeneratorFactory<TState> generatorFactory)
@@ -353,7 +360,7 @@ private void GenerateCode<TState>(
 
       try
       {
-         GenerateCode(context, ns, containingTypes, name, state, options, generatorFactory, stringBuilder);
+         GenerateCode(context, ns, containingTypes, name, numberOfGenerics, state, options, generatorFactory, stringBuilder);
       }
       finally
       {
@@ -366,6 +373,7 @@ private void GenerateCode<TState>(
       string? ns,
       IReadOnlyList<ContainingTypeState> containingTypes,
       string name,
+      int numberOfGenerics,
       TState state,
       GeneratorOptions options,
       ICodeGeneratorFactory<TState> generatorFactory,
@@ -396,7 +404,7 @@ private void GenerateCode<TState>(
 
          var generatedCode = stringBuilder.ToString();
 
-         context.EmitFile(ns, containingTypes, name, generatedCode, generator.FileNameSuffix);
+         context.EmitFile(ns, containingTypes, name, numberOfGenerics, generatedCode, generator.FileNameSuffix);
 
          if (Logger.IsEnabled(LogLevel.Information))
             Logger.Log(LogLevel.Information, $"Code generator '{generator.CodeGeneratorName}' emitted code for '{ns}.{name}'.");
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/ValueObjects/ComplexSerializerGeneratorState.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/ValueObjects/ComplexSerializerGeneratorState.cs
@@ -9,6 +9,7 @@ namespace Thinktecture.CodeAnalysis.ValueObjects;
    public string? Namespace => Type.Namespace;
    public IReadOnlyList<ContainingTypeState> ContainingTypes => Type.ContainingTypes;
    public string Name => Type.Name;
+   public IReadOnlyList<string> GenericsFullyQualified => [];
 
    public ComplexSerializerGeneratorState(
       ITypeInformation type,
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/ValueObjects/ComplexValueObjectSourceGeneratorState.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/ValueObjects/ComplexValueObjectSourceGeneratorState.cs
@@ -6,6 +6,7 @@ public sealed class ComplexValueObjectSourceGeneratorState : ITypeInformation, I
    public string TypeMinimallyQualified { get; }
    public bool IsEqualWithReferenceEquality => false;
    public IReadOnlyList<ContainingTypeState> ContainingTypes { get; }
+   public IReadOnlyList<string> GenericsFullyQualified => [];
 
    public string? Namespace { get; }
    public string Name { get; }
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/ValueObjects/KeyedValueObjectSourceGeneratorState.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/ValueObjects/KeyedValueObjectSourceGeneratorState.cs
@@ -6,6 +6,7 @@ public sealed class KeyedValueObjectSourceGeneratorState : ITypeInformation, IEq
    public string TypeMinimallyQualified { get; }
    public bool IsEqualWithReferenceEquality => false;
    public IReadOnlyList<ContainingTypeState> ContainingTypes { get; }
+   public IReadOnlyList<string> GenericsFullyQualified => [];
 
    public string? Namespace { get; }
    public string Name { get; }
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/SourceProductionContextExtensions.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/SourceProductionContextExtensions.cs
@@ -9,14 +9,15 @@ public static void EmitFile(
       string? typeNamespace,
       IReadOnlyList<ContainingTypeState> containingTypes,
       string typeName,
+      int numberOfGenerics,
       string? generatedCode,
       string? fileNameSuffix)
    {
       if (String.IsNullOrWhiteSpace(generatedCode))
          return;
 
       var containingTypeNames = containingTypes.Count == 0 ? null : String.Join(".", containingTypes.Select(t => t.Name)) + ".";
-      var hintName = $"{(typeNamespace is null ? null : $"{typeNamespace}.")}{containingTypeNames}{typeName}{fileNameSuffix}.g.cs";
+      var hintName = $"{(typeNamespace is null ? null : $"{typeNamespace}.")}{containingTypeNames}{typeName}{(numberOfGenerics > 0 ? $"`{numberOfGenerics}" : null)}{fileNameSuffix}.g.cs";
       context.AddSource(hintName, generatedCode!);
    }
 
diff --git a/test/Thinktecture.Runtime.Extensions.SourceGenerator.Tests/SourceGeneratorTests/Snapshots/UnionSourceGeneratorTests.Should_generate_record_with_and_without_generic_0.verified.cs b/test/Thinktecture.Runtime.Extensions.SourceGenerator.Tests/SourceGeneratorTests/Snapshots/UnionSourceGeneratorTests.Should_generate_record_with_and_without_generic_0.verified.cs
@@ -0,0 +1,132 @@
+﻿// <auto-generated />
+#nullable enable
+
+namespace Thinktecture.Tests;
+
+abstract partial record Result<T>
+{
+   private Result()
+   {
+   }
+
+   /// <summary>
+   /// Executes an action depending on the current type.
+   /// </summary>
+   /// <param name="success">The action to execute if the current type is <c>global::Thinktecture.Tests.Result&lt;T&gt;.Success</c>.</param>
+   /// <param name="failure">The action to execute if the current type is <c>global::Thinktecture.Tests.Result&lt;T&gt;.Failure</c>.</param>
+   public void Switch(
+      global::System.Action<global::Thinktecture.Tests.Result<T>.Success> @success,
+      global::System.Action<global::Thinktecture.Tests.Result<T>.Failure> @failure)
+   {
+      switch (this)
+      {
+         case global::Thinktecture.Tests.Result<T>.Success value:
+            @success(value);
+            return;
+         case global::Thinktecture.Tests.Result<T>.Failure value:
+            @failure(value);
+            return;
+         default:
+            throw new global::System.ArgumentOutOfRangeException($"Unexpected type '{this.GetType().FullName}'.");
+      }
+   }
+
+   /// <summary>
+   /// Executes an action depending on the current type.
+   /// </summary>
+   /// <param name="state">State to be passed to the callbacks.</param>
+   /// <param name="success">The action to execute if the current type is <c>global::Thinktecture.Tests.Result&lt;T&gt;.Success</c>.</param>
+   /// <param name="failure">The action to execute if the current type is <c>global::Thinktecture.Tests.Result&lt;T&gt;.Failure</c>.</param>
+   public void Switch<TState>(
+      TState state,
+      global::System.Action<TState, global::Thinktecture.Tests.Result<T>.Success> @success,
+      global::System.Action<TState, global::Thinktecture.Tests.Result<T>.Failure> @failure)
+#if NET9_0_OR_GREATER
+		where TState : allows ref struct
+#endif
+   {
+      switch (this)
+      {
+         case global::Thinktecture.Tests.Result<T>.Success value:
+            @success(state, value);
+            return;
+         case global::Thinktecture.Tests.Result<T>.Failure value:
+            @failure(state, value);
+            return;
+         default:
+            throw new global::System.ArgumentOutOfRangeException($"Unexpected type '{this.GetType().FullName}'.");
+      }
+   }
+
+   /// <summary>
+   /// Executes a function depending on the current type.
+   /// </summary>
+   /// <param name="success">The function to execute if the current type is <c>global::Thinktecture.Tests.Result&lt;T&gt;.Success</c>.</param>
+   /// <param name="failure">The function to execute if the current type is <c>global::Thinktecture.Tests.Result&lt;T&gt;.Failure</c>.</param>
+   public TResult Switch<TResult>(
+      global::System.Func<global::Thinktecture.Tests.Result<T>.Success, TResult> @success,
+      global::System.Func<global::Thinktecture.Tests.Result<T>.Failure, TResult> @failure)
+#if NET9_0_OR_GREATER
+		where TResult : allows ref struct
+#endif
+   {
+      switch (this)
+      {
+         case global::Thinktecture.Tests.Result<T>.Success value:
+            return @success(value);
+         case global::Thinktecture.Tests.Result<T>.Failure value:
+            return @failure(value);
+         default:
+            throw new global::System.ArgumentOutOfRangeException($"Unexpected type '{this.GetType().FullName}'.");
+      }
+   }
+
+   /// <summary>
+   /// Executes a function depending on the current type.
+   /// </summary>
+   /// <param name="state">State to be passed to the callbacks.</param>
+   /// <param name="success">The function to execute if the current type is <c>global::Thinktecture.Tests.Result&lt;T&gt;.Success</c>.</param>
+   /// <param name="failure">The function to execute if the current type is <c>global::Thinktecture.Tests.Result&lt;T&gt;.Failure</c>.</param>
+   public TResult Switch<TState, TResult>(
+      TState state,
+      global::System.Func<TState, global::Thinktecture.Tests.Result<T>.Success, TResult> @success,
+      global::System.Func<TState, global::Thinktecture.Tests.Result<T>.Failure, TResult> @failure)
+#if NET9_0_OR_GREATER
+		where TResult : allows ref struct
+		where TState : allows ref struct
+#endif
+   {
+      switch (this)
+      {
+         case global::Thinktecture.Tests.Result<T>.Success value:
+            return @success(state, value);
+         case global::Thinktecture.Tests.Result<T>.Failure value:
+            return @failure(state, value);
+         default:
+            throw new global::System.ArgumentOutOfRangeException($"Unexpected type '{this.GetType().FullName}'.");
+      }
+   }
+
+   /// <summary>
+   /// Maps current instance to an instance of type <typeparamref name="TResult"/>.
+   /// </summary>
+   /// <param name="success">The instance to return if the current type is <c>global::Thinktecture.Tests.Result&lt;T&gt;.Success</c>.</param>
+   /// <param name="failure">The instance to return if the current type is <c>global::Thinktecture.Tests.Result&lt;T&gt;.Failure</c>.</param>
+   public TResult Map<TResult>(
+      TResult @success,
+      TResult @failure)
+#if NET9_0_OR_GREATER
+		where TResult : allows ref struct
+#endif
+   {
+      switch (this)
+      {
+         case global::Thinktecture.Tests.Result<T>.Success value:
+               return @success;
+         case global::Thinktecture.Tests.Result<T>.Failure value:
+               return @failure;
+            default:
+               throw new global::System.ArgumentOutOfRangeException($"Unexpected type '{this.GetType().FullName}'.");
+         }
+   }
+}
diff --git a/test/Thinktecture.Runtime.Extensions.SourceGenerator.Tests/SourceGeneratorTests/Snapshots/UnionSourceGeneratorTests.Should_generate_record_with_and_without_generic_1.verified.cs b/test/Thinktecture.Runtime.Extensions.SourceGenerator.Tests/SourceGeneratorTests/Snapshots/UnionSourceGeneratorTests.Should_generate_record_with_and_without_generic_1.verified.cs
diff --git a/test/Thinktecture.Runtime.Extensions.SourceGenerator.Tests/SourceGeneratorTests/UnionSourceGeneratorTests.cs b/test/Thinktecture.Runtime.Extensions.SourceGenerator.Tests/SourceGeneratorTests/UnionSourceGeneratorTests.cs
diff --git a/test/Thinktecture.Runtime.Extensions.Tests.Shared/TestUnions/Result.cs b/test/Thinktecture.Runtime.Extensions.Tests.Shared/TestUnions/Result.cs

Original file line number	Diff line number	Diff line change
`@@ -5,4 +5,5 @@ public interface INamespaceAndName`
`5`	`5`	`string? Namespace { get; }`
`6`	`6`	`string Name { get; }`
`7`	`7`	`IReadOnlyList<ContainingTypeState> ContainingTypes { get; }`
	`8`	`+ IReadOnlyList<string> GenericsFullyQualified { get; }`
`8`	`9`	`}`