feat: add IgnoreObsoleteMembers

TimothyMakkison · Apr 29, 2023 · 825ac39 · 825ac39
1 parent e5e2d1c
commit 825ac39
Show file tree

Hide file tree

Showing 10 changed files with 309 additions and 3 deletions.
diff --git a/src/Riok.Mapperly.Abstractions/IgnoreObsoleteStrategy.cs b/src/Riok.Mapperly.Abstractions/IgnoreObsoleteStrategy.cs
@@ -0,0 +1,10 @@
+namespace Riok.Mapperly.Abstractions;
+
+[Flags]
+public enum IgnoreObsoleteStrategy
+{
+    None = 0,
+    Both = ~None,
+    Source = 1 << 0,
+    Target = 1 << 1,
+}
diff --git a/src/Riok.Mapperly.Abstractions/MapperAttribute.cs b/src/Riok.Mapperly.Abstractions/MapperAttribute.cs
@@ -70,4 +70,9 @@ public sealed class MapperAttribute : Attribute
     /// to keep track of and reuse existing target object instances.
     /// </summary>
     public bool UseReferenceHandling { get; set; }
+
+    /// <summary>
+    /// Sets the ingore Obsolete attribute strategy.
+    /// </summary>
+    public IgnoreObsoleteStrategy IgnoreObsoleteStrategy { get; set; } = IgnoreObsoleteStrategy.None;
 }
diff --git a/src/Riok.Mapperly.Abstractions/MapperIgnoreObsoleteMembersAttribute.cs b/src/Riok.Mapperly.Abstractions/MapperIgnoreObsoleteMembersAttribute.cs
@@ -0,0 +1,15 @@
+namespace Riok.Mapperly.Abstractions;
+
+/// <summary>
+/// Specifies options for obsolete ignoring strategy.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
+public sealed class MapperIgnoreObsoleteMembersAttribute : Attribute
+{
+    public MapperIgnoreObsoleteMembersAttribute(IgnoreObsoleteStrategy ignoreObsoleteStrategy = IgnoreObsoleteStrategy.Both)
+    {
+        IgnoreObsoleteStrategy = ignoreObsoleteStrategy;
+    }
+
+    public IgnoreObsoleteStrategy IgnoreObsoleteStrategy { get; }
+}
diff --git a/...k.Mapperly/Descriptors/MappingBodyBuilders/BuilderContext/MembersMappingBuilderContext.cs b/...k.Mapperly/Descriptors/MappingBodyBuilders/BuilderContext/MembersMappingBuilderContext.cs
@@ -66,19 +66,60 @@ private HashSet<string> InitIgnoredUnmatchedProperties(IEnumerable<string> allPr
 
     private HashSet<string> GetIgnoredTargetMembers()
     {
+        var obsoleteMembers = GetIgnoredObsoleteTargetMembers();
+
         return BuilderContext
             .ListConfiguration<MapperIgnoreTargetAttribute>()
             .Select(x => x.Target)
             // deprecated MapperIgnoreAttribute, but it is still supported by Mapperly.
 #pragma warning disable CS0618
             .Concat(BuilderContext.ListConfiguration<MapperIgnoreAttribute>().Select(x => x.Target))
 #pragma warning restore CS0618
+            .Concat(obsoleteMembers)
             .ToHashSet();
     }
 
+    private IEnumerable<string> GetIgnoredObsoleteTargetMembers()
+    {
+        var obosoleteAttribute = BuilderContext.ListConfiguration<MapperIgnoreObsoleteMembersAttribute>().FirstOrDefault();
+
+        if (
+            obosoleteAttribute is { IgnoreObsoleteStrategy: IgnoreObsoleteStrategy.Target or IgnoreObsoleteStrategy.Both }
+            || BuilderContext.MapperConfiguration.IgnoreObsoleteStrategy is IgnoreObsoleteStrategy.Target or IgnoreObsoleteStrategy.Both
+        )
+        {
+            return Mapping.SourceType
+                .GetAccessibleMappableMembers()
+                .Where(x => x.MemberSymbol.HasAttribute(BuilderContext.Types.ObsoleteAttribute))
+                .Select(x => x.Name);
+        }
+
+        return Enumerable.Empty<string>();
+    }
+
     private HashSet<string> GetIgnoredSourceMembers()
     {
-        return BuilderContext.ListConfiguration<MapperIgnoreSourceAttribute>().Select(x => x.Source).ToHashSet();
+        var obsoleteMembers = GetIgnoredObsoleteSourceMembers();
+
+        return BuilderContext.ListConfiguration<MapperIgnoreSourceAttribute>().Select(x => x.Source).Concat(obsoleteMembers).ToHashSet();
+    }
+
+    private IEnumerable<string> GetIgnoredObsoleteSourceMembers()
+    {
+        var obosoleteAttribute = BuilderContext.ListConfiguration<MapperIgnoreObsoleteMembersAttribute>().FirstOrDefault();
+
+        if (
+            obosoleteAttribute is { IgnoreObsoleteStrategy: IgnoreObsoleteStrategy.Source or IgnoreObsoleteStrategy.Both }
+            || BuilderContext.MapperConfiguration.IgnoreObsoleteStrategy is IgnoreObsoleteStrategy.Source or IgnoreObsoleteStrategy.Both
+        )
+        {
+            return Mapping.SourceType
+                .GetAccessibleMappableMembers()
+                .Where(x => x.MemberSymbol.HasAttribute(BuilderContext.Types.ObsoleteAttribute))
+                .Select(x => x.Name);
+        }
+
+        return Enumerable.Empty<string>();
     }
 
     private HashSet<string> GetSourceMemberNames()

diff --git a/src/Riok.Mapperly/Symbols/FieldMember.cs b/src/Riok.Mapperly/Symbols/FieldMember.cs
@@ -14,6 +14,7 @@ public FieldMember(IFieldSymbol fieldSymbol)
 
     public string Name => _fieldSymbol.Name;
     public ITypeSymbol Type => _fieldSymbol.Type;
+    public ISymbol MemberSymbol => _fieldSymbol;
     public bool IsNullable => _fieldSymbol.NullableAnnotation == NullableAnnotation.Annotated || Type.IsNullable();
     public bool IsIndexer => false;
     public bool CanGet => !_fieldSymbol.IsReadOnly && _fieldSymbol.IsAccessible();

diff --git a/src/Riok.Mapperly/Symbols/IMappableMember.cs b/src/Riok.Mapperly/Symbols/IMappableMember.cs
@@ -9,6 +9,8 @@ public interface IMappableMember
 
     ITypeSymbol Type { get; }
 
+    ISymbol MemberSymbol { get; }
+
     bool IsNullable { get; }
 
     bool IsIndexer { get; }

diff --git a/src/Riok.Mapperly/Symbols/PropertyMember.cs b/src/Riok.Mapperly/Symbols/PropertyMember.cs
@@ -14,6 +14,7 @@ internal PropertyMember(IPropertySymbol propertySymbol)
 
     public string Name => _propertySymbol.Name;
     public ITypeSymbol Type => _propertySymbol.Type;
+    public ISymbol MemberSymbol => _propertySymbol;
     public bool IsNullable => _propertySymbol.NullableAnnotation == NullableAnnotation.Annotated || Type.IsNullable();
     public bool IsIndexer => _propertySymbol.IsIndexer;
     public bool CanGet => !_propertySymbol.IsWriteOnly && _propertySymbol.GetMethod?.IsAccessible() != false;

diff --git a/test/Riok.Mapperly.Tests/Mapping/IgnoreObsoleteTest.cs b/test/Riok.Mapperly.Tests/Mapping/IgnoreObsoleteTest.cs
@@ -0,0 +1,227 @@
+using Riok.Mapperly.Abstractions;
+using Riok.Mapperly.Diagnostics;
+
+namespace Riok.Mapperly.Tests.Mapping;
+
+public class IgnoreObsoleteTest
+{
+    private readonly string _classA = """
+        class A
+        {
+            public int Value { get; set;}
+
+            [Obsolete]
+            public int Ignored { get; set;}
+        }
+        """;
+
+    private readonly string _classB = """
+        class B
+        {
+            public int Value { get; set;}
+
+            [Obsolete]
+            public int Ignored { get; set;}
+        }
+        """;
+
+    [Fact]
+    public void ClassAttributeIgnoreObsoleteNone()
+    {
+        var source = TestSourceBuilder.Mapping(
+            "A",
+            "B",
+            TestSourceBuilderOptions.WithIgnoreObsolete(IgnoreObsoleteStrategy.None),
+            _classA,
+            _classB
+        );
+
+        TestHelper
+            .GenerateMapper(source, TestHelperOptions.AllowInfoDiagnostics)
+            .Should()
+            .HaveSingleMethodBody(
+                """
+                var target = new global::B();
+                target.Value = source.Value;
+                target.Ignored = source.Ignored;
+                return target;
+                """
+            );
+    }
+
+    [Fact]
+    public void ClassAttributeIgnoreObsoleteBoth()
+    {
+        var source = TestSourceBuilder.Mapping(
+            "A",
+            "B",
+            TestSourceBuilderOptions.WithIgnoreObsolete(IgnoreObsoleteStrategy.Both),
+            _classA,
+            _classB
+        );
+
+        TestHelper
+            .GenerateMapper(source, TestHelperOptions.AllowInfoDiagnostics)
+            .Should()
+            .HaveSingleMethodBody(
+                """
+                var target = new global::B();
+                target.Value = source.Value;
+                return target;
+                """
+            );
+    }
+
+    [Fact]
+    public void ClassAttributeIgnoreSourceShouldDiagnostic()
+    {
+        var source = TestSourceBuilder.Mapping(
+            "A",
+            "B",
+            TestSourceBuilderOptions.WithIgnoreObsolete(IgnoreObsoleteStrategy.Source),
+            _classA,
+            _classB
+        );
+
+        TestHelper
+            .GenerateMapper(source, TestHelperOptions.AllowInfoDiagnostics)
+            .Should()
+            .HaveSingleMethodBody(
+                """
+                var target = new global::B();
+                target.Value = source.Value;
+                return target;
+                """
+            )
+            .HaveDiagnostic(new(DiagnosticDescriptors.SourceMemberNotFound));
+    }
+
+    [Fact]
+    public void ClassAttributeIgnoreTargetShouldDiagnostic()
+    {
+        var source = TestSourceBuilder.Mapping(
+            "A",
+            "B",
+            TestSourceBuilderOptions.WithIgnoreObsolete(IgnoreObsoleteStrategy.Target),
+            _classA,
+            _classB
+        );
+
+        TestHelper
+            .GenerateMapper(source, TestHelperOptions.AllowInfoDiagnostics)
+            .Should()
+            .HaveSingleMethodBody(
+                """
+                var target = new global::B();
+                target.Value = source.Value;
+                return target;
+                """
+            )
+            .HaveDiagnostic(new(DiagnosticDescriptors.SourceMemberNotMapped));
+    }
+
+    [Fact]
+    public void MethodAttributeIgnoreObsoleteNone()
+    {
+        var source = TestSourceBuilder.MapperWithBodyAndTypes(
+            "[MapperIgnoreObsoleteMembers(IgnoreObsoleteStrategy.None)] partial B Map(A source);",
+            _classA,
+            _classB
+        );
+
+        TestHelper
+            .GenerateMapper(source, TestHelperOptions.AllowInfoDiagnostics)
+            .Should()
+            .HaveSingleMethodBody(
+                """
+                var target = new global::B();
+                target.Value = source.Value;
+                target.Ignored = source.Ignored;
+                return target;
+                """
+            );
+    }
+
+    [Fact]
+    public void MethodAttributeIgnoreObsoleteBoth()
+    {
+        var source = TestSourceBuilder.MapperWithBodyAndTypes("[MapperIgnoreObsoleteMembers()] partial B Map(A source);", _classA, _classB);
+
+        TestHelper
+            .GenerateMapper(source, TestHelperOptions.AllowInfoDiagnostics)
+            .Should()
+            .HaveSingleMethodBody(
+                """
+                var target = new global::B();
+                target.Value = source.Value;
+                return target;
+                """
+            );
+    }
+
+    [Fact]
+    public void MethodAttributeIgnoreObsoleteSourceShouldDiagnostic()
+    {
+        var source = TestSourceBuilder.MapperWithBodyAndTypes(
+            "[MapperIgnoreObsoleteMembers(IgnoreObsoleteStrategy.Source)] partial B Map(A source);",
+            _classA,
+            _classB
+        );
+
+        TestHelper
+            .GenerateMapper(source, TestHelperOptions.AllowInfoDiagnostics)
+            .Should()
+            .HaveSingleMethodBody(
+                """
+                var target = new global::B();
+                target.Value = source.Value;
+                return target;
+                """
+            )
+            .HaveDiagnostic(new(DiagnosticDescriptors.SourceMemberNotFound));
+    }
+
+    [Fact]
+    public void MethodAttributeIgnoreObsoleteTargetShouldDiagnostic()
+    {
+        var source = TestSourceBuilder.MapperWithBodyAndTypes(
+            "[MapperIgnoreObsoleteMembers(IgnoreObsoleteStrategy.Target)] partial B Map(A source);",
+            _classA,
+            _classB
+        );
+
+        TestHelper
+            .GenerateMapper(source, TestHelperOptions.AllowInfoDiagnostics)
+            .Should()
+            .HaveSingleMethodBody(
+                """
+                var target = new global::B();
+                target.Value = source.Value;
+                return target;
+                """
+            )
+            .HaveDiagnostic(new(DiagnosticDescriptors.SourceMemberNotMapped));
+    }
+
+    [Fact]
+    public void MethodAttributeOverridesClassAttribute()
+    {
+        var source = TestSourceBuilder.MapperWithBodyAndTypes(
+            "[MapperIgnoreObsoleteMembers(IgnoreObsoleteStrategy.None)] partial B Map(A source);",
+            TestSourceBuilderOptions.WithIgnoreObsolete(IgnoreObsoleteStrategy.Both),
+            _classA,
+            _classB
+        );
+
+        TestHelper
+            .GenerateMapper(source, TestHelperOptions.AllowInfoDiagnostics)
+            .Should()
+            .HaveSingleMethodBody(
+                """
+                var target = new global::B();
+                target.Value = source.Value;
+                return target;
+                """
+            );
+    }
+}
diff --git a/test/Riok.Mapperly.Tests/TestSourceBuilder.cs b/test/Riok.Mapperly.Tests/TestSourceBuilder.cs
@@ -77,8 +77,8 @@ private static string BuildAttribute(TestSourceBuilderOptions options)
             Attribute(options.EnabledConversions),
             Attribute(options.PropertyNameMappingStrategy),
             Attribute(options.EnumMappingStrategy),
+            Attribute(options.IgnoreObsoleteStrategy),
         };
-
         return $"[Mapper({string.Join(", ", attrs)})]";
     }
 

diff --git a/test/Riok.Mapperly.Tests/TestSourceBuilderOptions.cs b/test/Riok.Mapperly.Tests/TestSourceBuilderOptions.cs
@@ -10,13 +10,17 @@ public record TestSourceBuilderOptions(
     bool ThrowOnPropertyMappingNullMismatch = false,
     PropertyNameMappingStrategy PropertyNameMappingStrategy = PropertyNameMappingStrategy.CaseSensitive,
     MappingConversionType EnabledConversions = MappingConversionType.All,
-    EnumMappingStrategy EnumMappingStrategy = EnumMappingStrategy.ByValue
+    EnumMappingStrategy EnumMappingStrategy = EnumMappingStrategy.ByValue,
+    IgnoreObsoleteStrategy IgnoreObsoleteStrategy = IgnoreObsoleteStrategy.None
 )
 {
     public static readonly TestSourceBuilderOptions Default = new();
     public static readonly TestSourceBuilderOptions WithDeepCloning = new(UseDeepCloning: true);
     public static readonly TestSourceBuilderOptions WithReferenceHandling = new(UseReferenceHandling: true);
 
+    public static TestSourceBuilderOptions WithIgnoreObsolete(IgnoreObsoleteStrategy ignoreObsoleteStrategy) =>
+        new(IgnoreObsoleteStrategy: ignoreObsoleteStrategy);
+
     public static TestSourceBuilderOptions WithDisabledMappingConversion(params MappingConversionType[] conversionTypes)
     {
         var enabled = MappingConversionType.All;