Implemented new method "Map" on smart enum that returns the provided instances.

Author: PawelGerr

samples/Thinktecture.Runtime.Extensions.Samples/SmartEnums/SmartEnumDemos.cs

@@ -23,16 +23,16 @@ private static void DemoForDailySalesCsvImporterType(ILogger logger)
       logger.Information("""
 
 
-==== Demo for Daily CSV-Importer-Type ====
+                         ==== Demo for Daily CSV-Importer-Type ====
 
-""");
+                         """);
 
       var type = SalesCsvImporterType.Daily;
 
       using var textReader = new StringReader("""
-id,datetime,volume
-1,20230425 10:45,345.67
-""");
+                                              id,datetime,volume
+                                              1,20230425 10:45,345.67
+                                              """);
 
       using var csvReader = new CsvReader(textReader, new CsvConfiguration(CultureInfo.InvariantCulture) { HasHeaderRecord = true });
 
@@ -54,20 +54,20 @@ private static void DemoForMonthlySalesCsvImporterType(ILogger logger)
       logger.Information("""
 
 
-==== Demo for Monthly CSV-Importer-Type ====
+                         ==== Demo for Monthly CSV-Importer-Type ====
 
-""");
+                         """);
 
       var with_3_columns = true;
       var csvWith3Columns = """
-volume,datetime,id
-123.45,20230426 11:50,2
-""";
+                            volume,datetime,id
+                            123.45,20230426 11:50,2
+                            """;
 
       var csvWith4Columns = """
-volume,quantity,id,datetime
-123.45,42,2,2023-04-25
-""";
+                            volume,quantity,id,datetime
+                            123.45,42,2,2023-04-25
+                            """;
 
       var type = SalesCsvImporterType.Monthly;
       var csv = with_3_columns ? csvWith3Columns : csvWith4Columns;
@@ -144,6 +144,11 @@ private static void DemoForNonValidatableEnum(ILogger logger)
 
       logger.Information(returnValue);
 
+      returnValue = productType.Map(ProductType.Groceries, "Map: Groceries",
+                                    ProductType.Housewares, "Map: Housewares");
+
+      logger.Information(returnValue);
+
       var parsed = ProductType.TryParse("Groceries", null, out var parsedProductType);
       logger.Information("Success: {Success} Parsed: {Parsed}", parsed, parsedProductType);
 

src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/Diagnostics/ThinktectureRuntimeExtensionsAnalyzer.cs

@@ -37,7 +37,7 @@ public sealed class ThinktectureRuntimeExtensionsAnalyzer : DiagnosticAnalyzer
                                                                                                               DiagnosticsDescriptors.EnumKeyShouldNotBeNullable,
                                                                                                               DiagnosticsDescriptors.EnumWithoutDerivedTypesMustBeSealed,
                                                                                                               DiagnosticsDescriptors.ValueObjectMustBeSealed,
-                                                                                                              DiagnosticsDescriptors.SwitchMustCoverAllItems,
+                                                                                                              DiagnosticsDescriptors.SwitchAndMapMustCoverAllItems,
                                                                                                               DiagnosticsDescriptors.DontImplementEnumInterfaceWithTwoGenerics,
                                                                                                               DiagnosticsDescriptors.ComparerTypeMustMatchMemberType,
                                                                                                               DiagnosticsDescriptors.ErrorDuringCodeAnalysis,
@@ -63,7 +63,7 @@ private static void AnalyzeMethodCall(OperationAnalysisContext context)
           || operation.Arguments.IsDefaultOrEmpty
           || operation.Arguments.Length % 2 != 0
           || operation.TargetMethod.IsStatic
-          || operation.TargetMethod.Name != "Switch")
+          || (operation.TargetMethod.Name != "Switch" && operation.TargetMethod.Name != "Map"))
       {
          return;
       }
@@ -101,7 +101,7 @@ private static void AnalyzeMethodCall(OperationAnalysisContext context)
       }
 
       if (!missingItemNames.IsDefaultOrEmpty)
-         ReportDiagnostic(context, DiagnosticsDescriptors.SwitchMustCoverAllItems, operation.Syntax.GetLocation(), operation.Instance.Type, String.Join(", ", missingItemNames));
+         ReportDiagnostic(context, DiagnosticsDescriptors.SwitchAndMapMustCoverAllItems, operation.Syntax.GetLocation(), operation.Instance.Type, String.Join(", ", missingItemNames));
    }
 
    private static void AnalyzeSmartEnum(SymbolAnalysisContext context)

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

@@ -29,7 +29,7 @@ internal static class DiagnosticsDescriptors
    public static readonly DiagnosticDescriptor EnumKeyShouldNotBeNullable = new("TTRESG036", "The key must not be nullable", "The generic type T of IEnum<T> and IValidatableEnum<T> must not be nullable", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Error, true);
    public static readonly DiagnosticDescriptor EnumWithoutDerivedTypesMustBeSealed = new("TTRESG037", "Enumeration without derived types must be sealed", "Enumeration '{0}' without derived types must be sealed", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Error, true);
    public static readonly DiagnosticDescriptor ValueObjectMustBeSealed = new("TTRESG038", "Value objects must be sealed", "Value object '{0}' must be sealed", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Error, true);
-   public static readonly DiagnosticDescriptor SwitchMustCoverAllItems = new("TTRESG039", "Switch must cover all items", "The switch-case on the enumeration '{0}' does not cover all items. Following items are not covered: {1}.", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Error, true);
+   public static readonly DiagnosticDescriptor SwitchAndMapMustCoverAllItems = new("TTRESG039", "The methods \"Switch\" and \"Map\" must cover all items", "The method \"Switch/Map\" on the enumeration '{0}' does not cover all items. Following items are not covered: {1}.", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Error, true);
    public static readonly DiagnosticDescriptor DontImplementEnumInterfaceWithTwoGenerics = new("TTRESG040", "Don't implement \"IEnum<TKey, T>\", implement \"IEnum<TKey>\" only", "The interface \"IEnum<{0}, {1}>\" will be implemented by Source Generator, implement \"IEnum<{0}>\" only", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Error, true);
    public static readonly DiagnosticDescriptor ComparerTypeMustMatchMemberType = new("TTRESG041", "The type of the comparer doesn't match the type of the member", "A comparer '{0}' doesn't match the type of the member", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Error, true);
    public static readonly DiagnosticDescriptor InitAccessorMustBePrivate = new("TTRESG042", "Property 'init' accessor must be private", "The 'init' accessor of the property '{0}' of the type '{1}' must be private", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Error, true);

src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/SmartEnums/EnumSettings.cs

@@ -12,6 +12,7 @@ public sealed class EnumSettings : IEquatable<EnumSettings>
    public bool SkipIFormattable { get; }
    public bool SkipToString { get; }
    public bool SkipSwitchMethods { get; }
+   public bool SkipMapMethods { get; }
 
    public EnumSettings(AttributeData? attribute)
    {
@@ -23,6 +24,7 @@ public EnumSettings(AttributeData? attribute)
       SkipIFormattable = attribute?.FindSkipIFormattable() ?? false;
       SkipToString = attribute?.FindSkipToString() ?? false;
       SkipSwitchMethods = attribute?.FindSkipSwitchMethods() ?? false;
+      SkipMapMethods = attribute?.FindSkipMapMethods() ?? false;
 
       // Comparison operators depend on the equality comparison operators
       if (ComparisonOperators > EqualityComparisonOperators)
@@ -48,7 +50,8 @@ public bool Equals(EnumSettings? other)
              && EqualityComparisonOperators == other.EqualityComparisonOperators
              && SkipIFormattable == other.SkipIFormattable
              && SkipToString == other.SkipToString
-             && SkipSwitchMethods == other.SkipSwitchMethods;
+             && SkipSwitchMethods == other.SkipSwitchMethods
+             && SkipMapMethods == other.SkipMapMethods;
    }
 
    public override int GetHashCode()
@@ -63,6 +66,7 @@ public override int GetHashCode()
          hashCode = (hashCode * 397) ^ SkipIFormattable.GetHashCode();
          hashCode = (hashCode * 397) ^ SkipToString.GetHashCode();
          hashCode = (hashCode * 397) ^ SkipSwitchMethods.GetHashCode();
+         hashCode = (hashCode * 397) ^ SkipMapMethods.GetHashCode();
 
          return hashCode;
       }

src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/SmartEnums/EnumSourceGeneratorState.cs

@@ -16,6 +16,7 @@ public sealed class EnumSourceGeneratorState : ITypeInformation, IEquatable<Enum
    public BaseTypeState? BaseType { get; }
    public bool SkipToString { get; }
    public bool SkipSwitchMethods { get; }
+   public bool SkipMapMethods { get; }
 
    public bool HasCreateInvalidItemImplementation { get; }
    public bool HasKeyComparerImplementation { get; }
@@ -35,6 +36,7 @@ public EnumSourceGeneratorState(
       IMemberState keyProperty,
       bool skipToString,
       bool skipSwitchMethods,
+      bool skipMapMethods,
       bool isValidatable,
       bool hasCreateInvalidItemImplementation,
       bool hasStructLayoutAttribute,
@@ -43,6 +45,7 @@ public EnumSourceGeneratorState(
       KeyProperty = keyProperty;
       SkipToString = skipToString;
       SkipSwitchMethods = skipSwitchMethods;
+      SkipMapMethods = skipMapMethods;
       IsValidatable = isValidatable;
       HasCreateInvalidItemImplementation = hasCreateInvalidItemImplementation;
       HasStructLayoutAttribute = hasStructLayoutAttribute;

src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/SmartEnums/SmartEnumCodeGenerator.cs

@@ -155,6 +155,9 @@ public override int GetHashCode()
          GenerateSwitchForFunc(true);
       }
 
+      if (!_state.SkipMapMethods)
+         GenerateMap();
+
       GenerateGetLookup();
 
       _sb.Append(@"
@@ -319,7 +322,7 @@ public T Switch<TContext, T>(
 
          _sb.Append("if (this == ").Append(itemNamePrefix).Append(i + 1).Append(@")
          {
-            return ").Append(itemNamePrefix).Append("Func").Append(i + 1).Append(@"(");
+            return ").Append(itemNamePrefix).Append("Func").Append(i + 1).Append("(");
 
          if (withContext)
             _sb.Append("context");
@@ -336,6 +339,63 @@ public T Switch<TContext, T>(
       }");
    }
 
+   private void GenerateMap()
+   {
+      if (_state.ItemNames.Count == 0)
+         return;
+
+      _sb.Append(@"
+
+      /// <summary>
+      /// Maps an item to an instance of type <typeparamref name=""T""/>.
+      /// </summary>");
+
+      var itemNamePrefix = _state.ArgumentName;
+
+      for (var i = 0; i < _state.ItemNames.Count; i++)
+      {
+         _sb.Append(@"
+      /// <param name=""").Append(itemNamePrefix).Append(i + 1).Append(@""">The item to compare to.</param>
+      /// <param name=""other").Append(i + 1).Append(@""">The instance to return if the current item is equal to <paramref name=""").Append(itemNamePrefix).Append(i + 1).Append(@"""/>.</param>");
+      }
+
+      _sb.Append(@"
+      public T Map<T>(");
+
+      for (var i = 0; i < _state.ItemNames.Count; i++)
+      {
+         if (i != 0)
+            _sb.Append(",");
+
+         _sb.Append(@"
+         ").Append(_state.Name).Append(" ").Append(itemNamePrefix).Append(i + 1)
+            .Append(", T ").Append("other").Append(i + 1);
+      }
+
+      _sb.Append(@")
+      {
+         ");
+
+      for (var i = 0; i < _state.ItemNames.Count; i++)
+      {
+         if (i != 0)
+            _sb.Append(@"
+         else ");
+
+         _sb.Append("if (this == ").Append(itemNamePrefix).Append(i + 1).Append(@")
+         {
+            return other").Append(i + 1).Append(@";
+         }");
+      }
+
+      _sb.Append(@"
+         else
+         {
+            throw new global::System.ArgumentOutOfRangeException($""No instance provided for the item '{this}'."");
+         }
+      }");
+   }
+
    private void GenerateModuleInitializer(IMemberState keyMember)
    {
       var enumType = _state.TypeFullyQualified;

src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/SmartEnums/SmartEnumSourceGenerator.cs

@@ -317,7 +317,8 @@ private bool IsEnumCandidate(TypeDeclarationSyntax typeDeclaration)
 
          var attributeInfo = new AttributeInfo(type);
 
-         var enumState = new EnumSourceGeneratorState(factory, type, keyProperty, settings.SkipToString, settings.SkipSwitchMethods, isValidatable, hasCreateInvalidItemImplementation, attributeInfo.HasStructLayoutAttribute, cancellationToken);
+         var enumState = new EnumSourceGeneratorState(factory, type, keyProperty, settings.SkipToString, settings.SkipSwitchMethods, settings.SkipMapMethods,
+                                                      isValidatable, hasCreateInvalidItemImplementation, attributeInfo.HasStructLayoutAttribute, cancellationToken);
          var derivedTypes = new SmartEnumDerivedTypes(enumState.Namespace, enumState.Name, enumState.TypeFullyQualified, enumState.IsReferenceType, FindDerivedTypes(type));
 
          Logger.LogDebug("The type declaration is a valid smart enum", namespaceAndName: enumState);

src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/AttributeDataExtensions.cs

@@ -85,6 +85,11 @@ public static OperatorsGeneration FindEqualityComparisonOperators(this Attribute
       return GetBooleanParameterValue(attributeData, "SkipSwitchMethods");
    }
 
+   public static bool? FindSkipMapMethods(this AttributeData attributeData)
+   {
+      return GetBooleanParameterValue(attributeData, "SkipMapMethods");
+   }
+
    public static (ITypeSymbol ComparerType, ITypeSymbol ItemType)? GetComparerTypes(this AttributeData attributeData)
    {
       if (attributeData.AttributeClass is not { } attributeClass || attributeClass.TypeKind == TypeKind.Error)

src/Thinktecture.Runtime.Extensions/EnumGenerationAttribute.cs

@@ -80,4 +80,9 @@ public OperatorsGeneration EqualityComparisonOperators
    /// Indication whether the generator should skip the implementation of the methods <code>Switch</code>.
    /// </summary>
    public bool SkipSwitchMethods { get; set; }
+
+   /// <summary>
+   /// Indication whether the generator should skip the implementation of the methods <code>Map</code>.
+   /// </summary>
+   public bool SkipMapMethods { get; set; }
 }

test/Thinktecture.Runtime.Extensions.SourceGenerator.Tests/AnalyzerAndCodeFixTests/TTRESG039_SwitchMustCoverAllItems.cs

@@ -5,12 +5,12 @@
 namespace Thinktecture.Runtime.Tests.AnalyzerAndCodeFixTests;
 
 // ReSharper disable InconsistentNaming
-public class TTRESG033_SwitchMustCoverAllItems
+public class TTRESG033_SwitchAndMapMustCoverAllItems
 {
    private const string _DIAGNOSTIC_ID = "TTRESG039";
 
    [Fact]
-   public async Task Should_trigger_on_missing_items_having_action()
+   public async Task Should_trigger_on_Switch_missing_items_having_action()
    {
       var code = @"
 using System;
@@ -36,7 +36,7 @@ public void Do()
    }
 
    [Fact]
-   public async Task Should_not_trigger_when_all_items_are_covered_having_action()
+   public async Task Should_not_trigger_on_Switch_when_all_items_are_covered_having_action()
    {
       var code = @"
 using System;
@@ -61,7 +61,7 @@ public void Do()
    }
 
    [Fact]
-   public async Task Should_trigger_on_missing_items_having_func()
+   public async Task Should_trigger_on_Switch_missing_items_having_func()
    {
       var code = @"
 using System;
@@ -87,7 +87,7 @@ public void Do()
    }
 
    [Fact]
-   public async Task Should_not_trigger_when_all_items_are_covered_having_func()
+   public async Task Should_not_trigger_on_Switch_when_all_items_are_covered_having_func()
    {
       var code = @"
 using System;
@@ -110,4 +110,55 @@ public void Do()
 
       await Verifier.VerifyAnalyzerAsync(code, new[] { typeof(ValueObjectAttribute).Assembly, typeof(TestEnum).Assembly });
    }
+
+   [Fact]
+   public async Task Should_trigger_on_Map_missing_items()
+   {
+      var code = @"
+using System;
+using Thinktecture;
+using Thinktecture.Runtime.Tests.TestEnums;
+
+namespace TestNamespace
+{
+   public class Test
+   {
+      public void Do()
+      {
+         var testEnum = TestEnum.Item1;
+
+         var returnValue = {|#0:testEnum.Map(TestEnum.Item1, 1,
+                            TestEnum.Item1, 2)|};
+      }
+   }
+}";
+
+      var expected = Verifier.Diagnostic(_DIAGNOSTIC_ID).WithLocation(0).WithArguments("TestEnum", "Item2");
+      await Verifier.VerifyAnalyzerAsync(code, new[] { typeof(ValueObjectAttribute).Assembly, typeof(TestEnum).Assembly }, expected);
+   }
+
+   [Fact]
+   public async Task Should_not_trigger_on_Map_when_all_items_are_covered()
+   {
+      var code = @"
+using System;
+using Thinktecture;
+using Thinktecture.Runtime.Tests.TestEnums;
+
+namespace TestNamespace
+{
+   public class Test
+   {
+      public void Do()
+      {
+         var testEnum = TestEnum.Item1;
+
+         var returnValue = {|#0:testEnum.Map(TestEnum.Item1, 1,
+                            TestEnum.Item2, 2)|};
+      }
+   }
+}";
+
+      await Verifier.VerifyAnalyzerAsync(code, new[] { typeof(ValueObjectAttribute).Assembly, typeof(TestEnum).Assembly });
+   }
 }