feat: support fields

docs/docs/02-configuration/01-mapper.md

@@ -87,6 +87,7 @@ except for ignored members)
 set the following two EditorConfig settings (see also [analyzer diagnostics](./13-analyzer-diagnostics.mdx)):
 
 ```editorconfig title=".editorconfig"
+[*.cs]
 dotnet_diagnostic.RMG012.severity = error # Unmapped target member
 dotnet_diagnostic.RMG020.severity = error # Unmapped source member
 ```

docs/docs/02-configuration/13-analyzer-diagnostics.mdx

@@ -20,6 +20,7 @@ Improvements are tracked in [#72](https://github.com/riok/mapperly/issues/72).
 The severity of these diagnostics can be customized via an `.editorconfig` file:
 
 ```editorconfig title=".editorconfig"
+[*.cs]
 dotnet_diagnostic.{RuleID}.severity = error
 dotnet_diagnostic.RMG020.severity = error
 ```

src/Riok.Mapperly/Descriptors/MappingBodyBuilders/BuilderContext/IMembersBuilderContext.cs

@@ -1,6 +1,6 @@
-using Microsoft.CodeAnalysis;
 using Riok.Mapperly.Abstractions;
 using Riok.Mapperly.Descriptors.Mappings;
+using Riok.Mapperly.Symbols;
 
 namespace Riok.Mapperly.Descriptors.MappingBodyBuilders.BuilderContext;
 
@@ -19,7 +19,7 @@ public interface IMembersBuilderContext<out T>
 
     IReadOnlyCollection<string> IgnoredSourceMemberNames { get; }
 
-    Dictionary<string, IPropertySymbol> TargetMembers { get; }
+    Dictionary<string, IMappableMember> TargetMembers { get; }
 
     Dictionary<string, List<MapPropertyAttribute>> MemberConfigsByRootTargetName { get; }
 }

src/Riok.Mapperly/Descriptors/MappingBodyBuilders/BuilderContext/MembersContainerBuilderContext.cs

@@ -1,6 +1,7 @@
 using Riok.Mapperly.Descriptors.Mappings.MemberMappings;
 using Riok.Mapperly.Diagnostics;
 using Riok.Mapperly.Helpers;
+using Riok.Mapperly.Symbols;
 
 namespace Riok.Mapperly.Descriptors.MappingBodyBuilders.BuilderContext;
 

src/Riok.Mapperly/Descriptors/MappingBodyBuilders/BuilderContext/MembersMappingBuilderContext.cs

@@ -1,9 +1,8 @@
-using Microsoft.CodeAnalysis;
 using Riok.Mapperly.Abstractions;
 using Riok.Mapperly.Descriptors.Mappings;
-using Riok.Mapperly.Descriptors.Mappings.MemberMappings;
 using Riok.Mapperly.Diagnostics;
 using Riok.Mapperly.Helpers;
+using Riok.Mapperly.Symbols;
 
 namespace Riok.Mapperly.Descriptors.MappingBodyBuilders.BuilderContext;
 
@@ -44,7 +43,7 @@ protected MembersMappingBuilderContext(MappingBuilderContext builderContext, T m
 
     public IReadOnlyCollection<string> IgnoredSourceMemberNames { get; }
 
-    public Dictionary<string, IPropertySymbol> TargetMembers { get; }
+    public Dictionary<string, IMappableMember> TargetMembers { get; }
 
     public Dictionary<string, List<MapPropertyAttribute>> MemberConfigsByRootTargetName { get; }
 
@@ -89,15 +88,15 @@ private HashSet<string> GetIgnoredSourceMembers()
     private HashSet<string> GetSourceMemberNames()
     {
         return Mapping.SourceType
-            .GetAllAccessibleProperties()
+            .GetAccessibleMappableMembers()
             .Select(x => x.Name)
             .ToHashSet();
     }
 
-    private Dictionary<string, IPropertySymbol> GetTargetMembers()
+    private Dictionary<string, IMappableMember> GetTargetMembers()
     {
         return Mapping.TargetType
-            .GetAllAccessibleProperties()
+            .GetAccessibleMappableMembers()
             .ToDictionary(x => x.Name, StringComparer.OrdinalIgnoreCase);
     }
 

src/Riok.Mapperly/Descriptors/MappingBodyBuilders/NewInstanceObjectMemberMappingBodyBuilder.cs

@@ -6,6 +6,7 @@
 using Riok.Mapperly.Descriptors.Mappings.MemberMappings;
 using Riok.Mapperly.Diagnostics;
 using Riok.Mapperly.Helpers;
+using Riok.Mapperly.Symbols;
 
 namespace Riok.Mapperly.Descriptors.MappingBodyBuilders;
 
@@ -30,9 +31,9 @@ public static void BuildMappingBody(MappingBuilderContext ctx, NewInstanceObject
         ObjectMemberMappingBodyBuilder.BuildMappingBody(mappingCtx);
     }
 
-    private static void BuildInitOnlyMemberMappings(INewInstanceBuilderContext<IMapping> ctx, bool includeAllProperties = false)
+    private static void BuildInitOnlyMemberMappings(INewInstanceBuilderContext<IMapping> ctx, bool includeAllMembers = false)
     {
-        var initOnlyTargetMembers = includeAllProperties
+        var initOnlyTargetMembers = includeAllMembers
             ? ctx.TargetMembers.Values.ToArray()
             : ctx.TargetMembers.Values.Where(x => x.CanOnlySetViaInitializer()).ToArray();
         foreach (var targetMember in initOnlyTargetMembers)
@@ -52,7 +53,7 @@ private static void BuildInitOnlyMemberMappings(INewInstanceBuilderContext<IMapp
                 out var sourceMemberPath))
             {
                 ctx.BuilderContext.ReportDiagnostic(
-                    targetMember.IsRequired()
+                    targetMember.IsRequired
                         ? DiagnosticDescriptors.RequiredMemberNotMapped
                         : DiagnosticDescriptors.SourceMemberNotFound,
                     targetMember.Name,
@@ -67,7 +68,7 @@ private static void BuildInitOnlyMemberMappings(INewInstanceBuilderContext<IMapp
 
     private static void BuildInitMemberMapping(
         INewInstanceBuilderContext<IMapping> ctx,
-        IPropertySymbol targetMember,
+        IMappableMember targetMember,
         IReadOnlyCollection<MapPropertyAttribute> memberConfigs)
     {
         // add configured mapping
@@ -108,13 +109,10 @@ private static void BuildInitMemberMapping(
 
     private static void BuildInitMemberMapping(
         INewInstanceBuilderContext<IMapping> ctx,
-        IPropertySymbol targetMember,
+        IMappableMember targetMember,
         MemberPath sourcePath)
     {
-        var targetPath = new MemberPath(new[]
-        {
-            targetMember
-        });
+        var targetPath = new MemberPath(new[] { targetMember });
         if (!ObjectMemberMappingBodyBuilder.ValidateMappingSpecification(ctx, sourcePath, targetPath, true))
             return;
 

src/Riok.Mapperly/Descriptors/MappingBodyBuilders/ObjectMemberMappingBodyBuilder.cs

@@ -4,6 +4,7 @@
 using Riok.Mapperly.Descriptors.Mappings.MemberMappings;
 using Riok.Mapperly.Diagnostics;
 using Riok.Mapperly.Helpers;
+using Riok.Mapperly.Symbols;
 
 namespace Riok.Mapperly.Descriptors.MappingBodyBuilders;
 
@@ -93,7 +94,7 @@ public static bool ValidateMappingSpecification(
         bool allowInitOnlyMember = false)
     {
         // the target member path is readonly or not accessible
-        if (!targetMemberPath.Member.CanSet())
+        if (!targetMemberPath.Member.CanSet)
         {
             ctx.BuilderContext.ReportDiagnostic(
                 DiagnosticDescriptors.CannotMapToReadOnlyMember,
@@ -107,7 +108,7 @@ public static bool ValidateMappingSpecification(
         }
 
         // a target member path part is write only or not accessible
-        if (targetMemberPath.ObjectPath.Any(p => !p.CanGet()))
+        if (targetMemberPath.ObjectPath.Any(p => !p.CanGet))
         {
             ctx.BuilderContext.ReportDiagnostic(
                 DiagnosticDescriptors.CannotMapToWriteOnlyMemberPath,
@@ -122,7 +123,7 @@ public static bool ValidateMappingSpecification(
 
         // a target member path part is init only
         var noInitOnlyPath = allowInitOnlyMember ? targetMemberPath.ObjectPath : targetMemberPath.Path;
-        if (noInitOnlyPath.Any(p => p.IsInitOnly()))
+        if (noInitOnlyPath.Any(p => p.IsInitOnly))
         {
             ctx.BuilderContext.ReportDiagnostic(
                 DiagnosticDescriptors.CannotMapToInitOnlyMemberPath,
@@ -136,7 +137,7 @@ public static bool ValidateMappingSpecification(
         }
 
         // a source member path is write only or not accessible
-        if (sourceMemberPath.Path.Any(p => !p.CanGet()))
+        if (sourceMemberPath.Path.Any(p => !p.CanGet))
         {
             ctx.BuilderContext.ReportDiagnostic(
                 DiagnosticDescriptors.CannotMapFromWriteOnlyMember,
@@ -209,7 +210,7 @@ private static void BuildMemberAssignmentMapping(
 
         // the source is nullable, or the mapping is a direct assignment and the target allows nulls
         // access the source in a null save matter (via ?.) but no other special handling required.
-        if (delegateMapping.SourceType.IsNullable() || delegateMapping.IsSynthetic && targetMemberPath.Member.IsNullable())
+        if (delegateMapping.SourceType.IsNullable() || delegateMapping.IsSynthetic && targetMemberPath.Member.IsNullable)
         {
             var memberMapping = new MemberMapping(
                 delegateMapping,
@@ -235,9 +236,9 @@ private static bool TryAddExistingTargetMapping(
         // if the member is readonly
         // and the target and source path is readable,
         // we try to create an existing target mapping
-        if (targetMemberPath.Member.CanSet()
-            || !targetMemberPath.Path.All(op => op.CanGet())
-            || !sourceMemberPath.Path.All(op => op.CanGet()))
+        if (targetMemberPath.Member.CanSet
+            || !targetMemberPath.Path.All(op => op.CanGet)
+            || !sourceMemberPath.Path.All(op => op.CanGet))
         {
             return false;
         }

src/Riok.Mapperly/Descriptors/MappingBuilders/DictionaryMappingBuilder.cs

@@ -23,8 +23,7 @@ public static class DictionaryMappingBuilder
         // The constructed type should be Dictionary<,>
         if (IsDictionaryType(ctx, ctx.Target))
         {
-            var sourceHasCount = ctx.Source.GetAllMembers(CountPropertyName)
-                .OfType<IPropertySymbol>()
+            var sourceHasCount = ctx.Source.GetAllProperties(CountPropertyName)
                 .Any(x => !x.IsStatic && !x.IsIndexer && !x.IsWriteOnly && x.Type.SpecialType == SpecialType.System_Int32);
 
             var targetDictionarySymbol = ctx.Types.DictionaryT.Construct(keyMapping.TargetType, valueMapping.TargetType);

src/Riok.Mapperly/Descriptors/MappingBuilders/ParseMappingBuilder.cs

@@ -19,8 +19,7 @@ public static class ParseMappingBuilder
 
         var targetIsNullable = ctx.Target.NonNullable(out var nonNullableTarget);
 
-        var parseMethodCandidates = nonNullableTarget.GetAllMembers(ParseMethodName)
-            .OfType<IMethodSymbol>()
+        var parseMethodCandidates = nonNullableTarget.GetAllMethods(ParseMethodName)
             .Where(m =>
                 m.IsStatic
                 && !m.ReturnsVoid

src/Riok.Mapperly/Descriptors/Mappings/MemberMappings/IMemberAssignmentMapping.cs

@@ -1,4 +1,5 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Riok.Mapperly.Symbols;
 
 namespace Riok.Mapperly.Descriptors.Mappings.MemberMappings;
 

src/Riok.Mapperly/Descriptors/Mappings/MemberMappings/IMemberMapping.cs

@@ -1,4 +1,5 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Riok.Mapperly.Symbols;
 
 namespace Riok.Mapperly.Descriptors.Mappings.MemberMappings;
 

src/Riok.Mapperly/Descriptors/Mappings/MemberMappings/MemberAssignmentMapping.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Riok.Mapperly.Symbols;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
 using static Riok.Mapperly.Emit.SyntaxFactoryHelper;
 

src/Riok.Mapperly/Descriptors/Mappings/MemberMappings/MemberExistingTargetMapping.cs

@@ -1,5 +1,6 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Riok.Mapperly.Descriptors.Mappings.ExistingTarget;
+using Riok.Mapperly.Symbols;
 
 namespace Riok.Mapperly.Descriptors.Mappings.MemberMappings;
 

src/Riok.Mapperly/Descriptors/Mappings/MemberMappings/MemberMapping.cs

@@ -1,4 +1,5 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Riok.Mapperly.Symbols;
 
 namespace Riok.Mapperly.Descriptors.Mappings.MemberMappings;
 

src/Riok.Mapperly/Descriptors/Mappings/MemberMappings/MemberNullAssignmentInitializerMapping.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Riok.Mapperly.Symbols;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
 using static Riok.Mapperly.Emit.SyntaxFactoryHelper;
 

src/Riok.Mapperly/Descriptors/Mappings/MemberMappings/MemberNullDelegateAssignmentMapping.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Riok.Mapperly.Symbols;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
 using static Riok.Mapperly.Emit.SyntaxFactoryHelper;
 

src/Riok.Mapperly/Descriptors/Mappings/MemberMappings/NullMemberMapping.cs

@@ -2,6 +2,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Riok.Mapperly.Helpers;
+using Riok.Mapperly.Symbols;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
 using static Riok.Mapperly.Emit.SyntaxFactoryHelper;
 

src/Riok.Mapperly/Descriptors/UserMethodMappingExtractor.cs

@@ -44,8 +44,8 @@ private static IEnumerable<IMethodSymbol> ExtractMethods(ITypeSymbol mapperSymbo
 
     private static IEnumerable<IMethodSymbol> ExtractBaseMethods(INamedTypeSymbol objectType, ITypeSymbol mapperSymbol)
     {
-        var baseMethods = mapperSymbol.BaseType?.GetAllMembers() ?? Enumerable.Empty<ISymbol>();
-        var intfMethods = mapperSymbol.AllInterfaces.SelectMany(x => x.GetAllMembers());
+        var baseMethods = mapperSymbol.BaseType?.GetAllMethods() ?? Enumerable.Empty<ISymbol>();
+        var intfMethods = mapperSymbol.AllInterfaces.SelectMany(x => x.GetAllMethods());
         return baseMethods
             .Concat(intfMethods)
             .OfType<IMethodSymbol>()

src/Riok.Mapperly/Helpers/SymbolExtensions.cs

@@ -2,6 +2,7 @@
 
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
+using Riok.Mapperly.Symbols;
 
 namespace Riok.Mapperly.Helpers;
 
@@ -34,11 +35,14 @@ internal static bool TryGetEnumUnderlyingType(this ITypeSymbol t, [NotNullWhen(t
         return enumType != null;
     }
 
-    internal static IEnumerable<ISymbol> GetAllMembers(this ITypeSymbol symbol, string name)
-        => symbol.GetAllMembers(name, StringComparer.Ordinal);
+    internal static IEnumerable<IMethodSymbol> GetAllMethods(this ITypeSymbol symbol)
+        => symbol.GetAllMembers().OfType<IMethodSymbol>();
 
-    internal static IEnumerable<ISymbol> GetAllMembers(this ITypeSymbol symbol, string name, IEqualityComparer<string> comparer)
-        => symbol.GetAllMembers().Where(x => comparer.Equals(name, x.Name));
+    internal static IEnumerable<IMethodSymbol> GetAllMethods(this ITypeSymbol symbol, string name)
+        => symbol.GetAllMembers(name).OfType<IMethodSymbol>();
+
+    internal static IEnumerable<IPropertySymbol> GetAllProperties(this ITypeSymbol symbol, string name)
+        => symbol.GetAllMembers(name).OfType<IPropertySymbol>();
 
     internal static IEnumerable<ISymbol> GetAllMembers(this ITypeSymbol symbol)
     {
@@ -55,13 +59,23 @@ internal static IEnumerable<ISymbol> GetAllMembers(this ITypeSymbol symbol)
             : members.Concat(symbol.BaseType.GetAllMembers());
     }
 
-    internal static IEnumerable<IPropertySymbol> GetAllAccessibleProperties(this ITypeSymbol symbol)
+    internal static IEnumerable<IMappableMember> GetMappableMembers(this ITypeSymbol symbol, string name, IEqualityComparer<string> comparer)
+    {
+        return symbol
+            .GetAllMembers()
+            .Where(x => comparer.Equals(name, x.Name) && !x.IsStatic)
+            .Select(MappableMember.Create)
+            .WhereNotNull();
+    }
+
+    internal static IEnumerable<IMappableMember> GetAccessibleMappableMembers(this ITypeSymbol symbol)
     {
         return symbol
             .GetAllMembers()
-            .OfType<IPropertySymbol>()
             .Where(x => x.IsAccessible())
-            .DistinctBy(x => x.Name);
+            .DistinctBy(x => x.Name)
+            .Select(MappableMember.Create)
+            .WhereNotNull();
     }
 
     internal static bool ImplementsGeneric(
@@ -125,4 +139,7 @@ internal static bool CanConsumeType(this ITypeParameterSymbol typeParameter, Com
 
         return true;
     }
+
+    private static IEnumerable<ISymbol> GetAllMembers(this ITypeSymbol symbol, string name)
+        => symbol.GetAllMembers().Where(x => name.Equals(x.Name));
 }