chore(deps): Bump csharpier from 0.26.5 to 0.26.7

.config/dotnet-tools.json

@@ -27,7 +27,7 @@
       ]
     },
     "csharpier": {
-      "version": "0.26.5",
+      "version": "0.26.7",
       "commands": [
         "dotnet-csharpier"
       ]

src/Riok.Mapperly/Descriptors/Enumerables/EnsureCapacity/EnsureCapacityBuilder.cs

@@ -15,8 +15,7 @@ public static class EnsureCapacityBuilder
         if (ctx.CollectionInfos == null)
             return null;
 
-        var capacityMethod = ctx.SymbolAccessor
-            .GetAllMethods(ctx.Target, EnsureCapacityName)
+        var capacityMethod = ctx.SymbolAccessor.GetAllMethods(ctx.Target, EnsureCapacityName)
             .FirstOrDefault(x => x.Parameters.Length == 1 && x.Parameters[0].Type.SpecialType == SpecialType.System_Int32 && !x.IsStatic);
 
         // if EnsureCapacity is not available then return null
@@ -31,8 +30,7 @@ public static class EnsureCapacityBuilder
         if (ctx.CollectionInfos.Source.CountIsKnown)
             return new EnsureCapacityMember(ctx.CollectionInfos.Target.CountPropertyName, ctx.CollectionInfos.Source.CountPropertyName);
 
-        var nonEnumeratedCountMethod = ctx.Types
-            .Get(typeof(Enumerable))
+        var nonEnumeratedCountMethod = ctx.Types.Get(typeof(Enumerable))
             .GetMembers(TryGetNonEnumeratedCountMethodName)
             .OfType<IMethodSymbol>()
             .FirstOrDefault(

src/Riok.Mapperly/Descriptors/ExternalMappings/ExternalMappingsExtractor.cs

@@ -11,8 +11,7 @@ internal static class ExternalMappingsExtractor
 {
     public static IEnumerable<IUserMapping> ExtractExternalMappings(SimpleMappingBuilderContext ctx, INamedTypeSymbol mapperSymbol)
     {
-        var staticExternalMappers = ctx.AttributeAccessor
-            .Access<UseStaticMapperAttribute, UseStaticMapperConfiguration>(mapperSymbol)
+        var staticExternalMappers = ctx.AttributeAccessor.Access<UseStaticMapperAttribute, UseStaticMapperConfiguration>(mapperSymbol)
             .Concat(ctx.AttributeAccessor.Access<UseStaticMapperAttribute<object>, UseStaticMapperConfiguration>(mapperSymbol))
             .SelectMany(
                 x =>
@@ -24,8 +23,7 @@ public static IEnumerable<IUserMapping> ExtractExternalMappings(SimpleMappingBui
                     )
             );
 
-        var externalInstanceMappers = ctx.SymbolAccessor
-            .GetAllMembers(mapperSymbol)
+        var externalInstanceMappers = ctx.SymbolAccessor.GetAllMembers(mapperSymbol)
             .Where(x => ctx.AttributeAccessor.HasAttribute<UseMapperAttribute>(x))
             .SelectMany(x => ValidateAndExtractExternalInstanceMappings(ctx, x));
 

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

@@ -30,16 +30,10 @@ protected MembersMappingBuilderContext(MappingBuilderContext builderContext, T m
         TargetMembers = GetTargetMembers();
 
         IgnoredSourceMemberNames = builderContext
-            .Configuration
-            .Properties
-            .IgnoredSources
-            .Concat(GetIgnoredObsoleteSourceMembers())
+            .Configuration.Properties.IgnoredSources.Concat(GetIgnoredObsoleteSourceMembers())
             .ToHashSet();
         var ignoredTargetMemberNames = builderContext
-            .Configuration
-            .Properties
-            .IgnoredTargets
-            .Concat(GetIgnoredObsoleteTargetMembers())
+            .Configuration.Properties.IgnoredTargets.Concat(GetIgnoredObsoleteTargetMembers())
             .ToHashSet();
 
         _ignoredUnmatchedSourceMemberNames = InitIgnoredUnmatchedProperties(IgnoredSourceMemberNames, _unmappedSourceMemberNames);
@@ -54,8 +48,7 @@ protected MembersMappingBuilderContext(MappingBuilderContext builderContext, T m
 
         // source and target properties may have been ignored and mapped explicitly
         _mappedAndIgnoredSourceMemberNames = MemberConfigsByRootTargetName
-            .Values
-            .SelectMany(v => v.Select(s => s.Source.Path.First()))
+            .Values.SelectMany(v => v.Select(s => s.Source.Path.First()))
             .ToHashSet();
         _mappedAndIgnoredSourceMemberNames.IntersectWith(IgnoredSourceMemberNames);
 
@@ -106,8 +99,7 @@ private IEnumerable<string> GetIgnoredObsoleteTargetMembers()
             return Enumerable.Empty<string>();
 
         return BuilderContext
-            .SymbolAccessor
-            .GetAllAccessibleMappableMembers(Mapping.TargetType)
+            .SymbolAccessor.GetAllAccessibleMappableMembers(Mapping.TargetType)
             .Where(x => BuilderContext.SymbolAccessor.HasAttribute<ObsoleteAttribute>(x.MemberSymbol))
             .Select(x => x.Name);
     }
@@ -120,8 +112,7 @@ private IEnumerable<string> GetIgnoredObsoleteSourceMembers()
             return Enumerable.Empty<string>();
 
         return BuilderContext
-            .SymbolAccessor
-            .GetAllAccessibleMappableMembers(Mapping.SourceType)
+            .SymbolAccessor.GetAllAccessibleMappableMembers(Mapping.SourceType)
             .Where(x => BuilderContext.SymbolAccessor.HasAttribute<ObsoleteAttribute>(x.MemberSymbol))
             .Select(x => x.Name);
     }
@@ -134,18 +125,14 @@ private HashSet<string> GetSourceMemberNames()
     private Dictionary<string, IMappableMember> GetTargetMembers()
     {
         return BuilderContext
-            .SymbolAccessor
-            .GetAllAccessibleMappableMembers(Mapping.TargetType)
+            .SymbolAccessor.GetAllAccessibleMappableMembers(Mapping.TargetType)
             .ToDictionary(x => x.Name, StringComparer.OrdinalIgnoreCase);
     }
 
     private Dictionary<string, List<PropertyMappingConfiguration>> GetMemberConfigurations()
     {
         return BuilderContext
-            .Configuration
-            .Properties
-            .ExplicitMappings
-            .GroupBy(x => x.Target.Path.First())
+            .Configuration.Properties.ExplicitMappings.GroupBy(x => x.Target.Path.First())
             .ToDictionary(x => x.Key, x => x.ToList());
     }
 

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

@@ -50,15 +50,13 @@ private static void BuildInitOnlyMemberMappings(INewInstanceBuilderContext<IMapp
             }
 
             if (
-                !ctx.BuilderContext
-                    .SymbolAccessor
-                    .TryFindMemberPath(
-                        ctx.Mapping.SourceType,
-                        MemberPathCandidateBuilder.BuildMemberPathCandidates(targetMember.Name),
-                        ctx.IgnoredSourceMemberNames,
-                        ignoreCase,
-                        out var sourceMemberPath
-                    )
+                !ctx.BuilderContext.SymbolAccessor.TryFindMemberPath(
+                    ctx.Mapping.SourceType,
+                    MemberPathCandidateBuilder.BuildMemberPathCandidates(targetMember.Name),
+                    ctx.IgnoredSourceMemberNames,
+                    ignoreCase,
+                    out var sourceMemberPath
+                )
             )
             {
                 if (targetMember.IsRequired)
@@ -208,8 +206,7 @@ private static void BuildConstructorMapping(INewInstanceBuilderContext<IMapping>
         // then by descending parameter count
         // ctors annotated with [Obsolete] are considered last unless they have a MapperConstructor attribute set
         var ctorCandidates = namedTargetType
-            .InstanceConstructors
-            .Where(ctor => ctx.BuilderContext.SymbolAccessor.IsDirectlyAccessible(ctor))
+            .InstanceConstructors.Where(ctor => ctx.BuilderContext.SymbolAccessor.IsDirectlyAccessible(ctor))
             .OrderByDescending(x => ctx.BuilderContext.SymbolAccessor.HasAttribute<MapperConstructorAttribute>(x))
             .ThenBy(x => ctx.BuilderContext.SymbolAccessor.HasAttribute<ObsoleteAttribute>(x))
             .ThenByDescending(x => x.Parameters.Length == 0)
@@ -325,15 +322,13 @@ out PropertyMappingConfiguration? memberConfig
             || !ctx.MemberConfigsByRootTargetName.TryGetValue(parameterName, out var memberConfigs)
         )
         {
-            return ctx.BuilderContext
-                .SymbolAccessor
-                .TryFindMemberPath(
-                    ctx.Mapping.SourceType,
-                    MemberPathCandidateBuilder.BuildMemberPathCandidates(parameter.Name),
-                    ctx.IgnoredSourceMemberNames,
-                    true,
-                    out sourcePath
-                );
+            return ctx.BuilderContext.SymbolAccessor.TryFindMemberPath(
+                ctx.Mapping.SourceType,
+                MemberPathCandidateBuilder.BuildMemberPathCandidates(parameter.Name),
+                ctx.IgnoredSourceMemberNames,
+                true,
+                out sourcePath
+            );
         }
 
         if (memberConfigs.Count > 1)

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

@@ -182,15 +182,13 @@ out MemberPath? sourcePath
         var ignoreCase = ctx.BuilderContext.MapperConfiguration.PropertyNameMappingStrategy == PropertyNameMappingStrategy.CaseInsensitive;
 
         if (
-            ctx.BuilderContext
-                .SymbolAccessor
-                .TryFindMemberPath(
-                    ctx.Mapping.SourceType,
-                    MemberPathCandidateBuilder.BuildMemberPathCandidates(field.Name),
-                    ctx.IgnoredSourceMemberNames,
-                    ignoreCase,
-                    out sourcePath
-                )
+            ctx.BuilderContext.SymbolAccessor.TryFindMemberPath(
+                ctx.Mapping.SourceType,
+                MemberPathCandidateBuilder.BuildMemberPathCandidates(field.Name),
+                ctx.IgnoredSourceMemberNames,
+                ignoreCase,
+                out sourcePath
+            )
         )
         {
             return true;
@@ -201,14 +199,12 @@ out sourcePath
         if (!ctx.Mapping.SourceType.IsTupleType || ctx.Mapping.SourceType is not INamedTypeSymbol namedType)
             return false;
 
-        var mappableField = namedType
-            .TupleElements
-            .FirstOrDefault(
-                x =>
-                    x.CorrespondingTupleField != default
-                    && !ctx.IgnoredSourceMemberNames.Contains(x.Name)
-                    && string.Equals(field.CorrespondingTupleField!.Name, x.CorrespondingTupleField!.Name)
-            );
+        var mappableField = namedType.TupleElements.FirstOrDefault(
+            x =>
+                x.CorrespondingTupleField != default
+                && !ctx.IgnoredSourceMemberNames.Contains(x.Name)
+                && string.Equals(field.CorrespondingTupleField!.Name, x.CorrespondingTupleField!.Name)
+        );
 
         if (mappableField == default)
             return false;

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

@@ -41,15 +41,13 @@ public static void BuildMappingBody(IMembersContainerBuilderContext<IMemberAssig
             }
 
             if (
-                ctx.BuilderContext
-                    .SymbolAccessor
-                    .TryFindMemberPath(
-                        ctx.Mapping.SourceType,
-                        MemberPathCandidateBuilder.BuildMemberPathCandidates(targetMember.Name),
-                        ctx.IgnoredSourceMemberNames,
-                        ignoreCase,
-                        out var sourceMemberPath
-                    )
+                ctx.BuilderContext.SymbolAccessor.TryFindMemberPath(
+                    ctx.Mapping.SourceType,
+                    MemberPathCandidateBuilder.BuildMemberPathCandidates(targetMember.Name),
+                    ctx.IgnoredSourceMemberNames,
+                    ignoreCase,
+                    out var sourceMemberPath
+                )
             )
             {
                 BuildMemberAssignmentMapping(ctx, sourceMemberPath, new MemberPath(new[] { targetMember }));

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

@@ -18,9 +18,11 @@ public static void BuildMappingBody(MappingBuilderContext ctx, UserDefinedNewIns
             .Where(
                 x =>
                     DoesTypesSatisfySubstitutionPrinciples(mapping, ctx.SymbolAccessor, x.SourceType.NonNullable(), x.TargetType)
-                    && mapping
-                        .TypeParameters
-                        .DoesTypesSatisfyTypeParameterConstraints(ctx.SymbolAccessor, x.SourceType.NonNullable(), x.TargetType)
+                    && mapping.TypeParameters.DoesTypesSatisfyTypeParameterConstraints(
+                        ctx.SymbolAccessor,
+                        x.SourceType.NonNullable(),
+                        x.TargetType
+                    )
             );
 
         BuildMappingBody(ctx, mapping, mappings);

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

@@ -17,8 +17,7 @@ public static class CtorMappingBuilder
 
         // resolve ctors which have the source as single argument
         var ctorMethod = namedTarget
-            .InstanceConstructors
-            .Where(ctx.SymbolAccessor.IsDirectlyAccessible)
+            .InstanceConstructors.Where(ctx.SymbolAccessor.IsDirectlyAccessible)
             .FirstOrDefault(
                 m =>
                     m.Parameters.Length == 1

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

@@ -151,13 +151,11 @@ INewInstanceMapping valueMapping
         var enumerableType = ctx.Types.Get(typeof(IEnumerable<>));
         var dictionaryType = ctx.Types.Get(typeof(Dictionary<,>));
 
-        var fromEnumerableCtor = dictionaryType
-            .Constructors
-            .FirstOrDefault(
-                x =>
-                    x.Parameters.Length == 1
-                    && SymbolEqualityComparer.Default.Equals(((INamedTypeSymbol)x.Parameters[0].Type).ConstructedFrom, enumerableType)
-            );
+        var fromEnumerableCtor = dictionaryType.Constructors.FirstOrDefault(
+            x =>
+                x.Parameters.Length == 1
+                && SymbolEqualityComparer.Default.Equals(((INamedTypeSymbol)x.Parameters[0].Type).ConstructedFrom, enumerableType)
+        );
 
         if (fromEnumerableCtor != null)
         {

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

@@ -88,8 +88,7 @@ _ when ctx.SymbolAccessor.HasAttribute<FlagsAttribute>(ctx.Target) => EnumCastMa
             fallbackMapping
         );
         var differentValueExplicitEnumMappings = enumMemberMappings
-            .ExplicitMemberMappings
-            .Where(x => x.Key.ConstantValue?.Equals(x.Value.ConstantValue) != true)
+            .ExplicitMemberMappings.Where(x => x.Key.ConstantValue?.Equals(x.Value.ConstantValue) != true)
             .ToDictionary(x => x.Key, x => x.Value, (IEqualityComparer<IFieldSymbol>)SymbolEqualityComparer.Default);
 
         if (differentValueExplicitEnumMappings.Count == 0)
@@ -135,13 +134,11 @@ params IEqualityComparer<T>[] propertyComparer
         var explicitMappings = ignoreExplicitAndIgnoredMappings
             ? new Dictionary<IFieldSymbol, IFieldSymbol>(SymbolEqualityComparer.Default)
             : BuildExplicitValueMappings(ctx);
-        var sourceMembers = ctx.Source
-            .GetMembers()
+        var sourceMembers = ctx.Source.GetMembers()
             .OfType<IFieldSymbol>()
             .Where(x => !ignoredSourceMembers.Remove(x))
             .ToHashSet(FieldSymbolEqualityComparer.Default);
-        var targetMembers = ctx.Target
-            .GetMembers()
+        var targetMembers = ctx.Target.GetMembers()
             .OfType<IFieldSymbol>()
             .Where(x => !ignoredTargetMembers.Remove(x))
             .ToHashSet(FieldSymbolEqualityComparer.Default);

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

@@ -257,9 +257,9 @@ private static LinqEnumerableMapping BuildLinqMapping(
             return null;
 
         var typedEnumerable = ctx.Types.Get(typeof(IEnumerable<>)).Construct(typeSymbol);
-        var hasCtor = namedType
-            .Constructors
-            .Any(m => m.Parameters.Length == 1 && SymbolEqualityComparer.Default.Equals(m.Parameters[0].Type, typedEnumerable));
+        var hasCtor = namedType.Constructors.Any(
+            m => m.Parameters.Length == 1 && SymbolEqualityComparer.Default.Equals(m.Parameters[0].Type, typedEnumerable)
+        );
         if (hasCtor)
             return namedType;
 

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 = ctx.SymbolAccessor
-            .GetAllMethods(nonNullableTarget, ParseMethodName)
+        var parseMethodCandidates = ctx.SymbolAccessor.GetAllMethods(nonNullableTarget, ParseMethodName)
             .Where(
                 m =>
                     m.IsStatic

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

@@ -17,8 +17,7 @@ public static class StringToEnumMappingBuilder
         if (ctx.Source.SpecialType != SpecialType.System_String || !ctx.Target.IsEnum())
             return null;
 
-        var genericEnumParseMethodSupported = ctx.Types
-            .Get<Enum>()
+        var genericEnumParseMethodSupported = ctx.Types.Get<Enum>()
             .GetMembers(nameof(Enum.Parse))
             .OfType<IMethodSymbol>()
             .Any(x => x.IsGenericMethod);

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

@@ -67,8 +67,7 @@ private static bool HasToStringMethodWithNullableParameter(MappingBuilderContext
 
     private static IMethodSymbol? FindToStringMethod(MappingBuilderContext ctx, bool stringFormatParam, bool formatProviderParam)
     {
-        return ctx.SymbolAccessor
-            .GetAllMethods(ctx.Source, nameof(ToString))
+        return ctx.SymbolAccessor.GetAllMethods(ctx.Source, nameof(ToString))
             .FirstOrDefault(m => IsToStringMethod(ctx, m, stringFormatParam, formatProviderParam));
     }
 

src/Riok.Mapperly/Descriptors/Mappings/DerivedExistingTargetTypeSwitchMapping.cs

@@ -27,8 +27,7 @@ public override IEnumerable<StatementSyntax> Build(TypeMappingBuildContext ctx,
         var caseSections = existingTargetTypeMappings.Select(x => BuildSwitchSection(ctx, x));
         var defaultSection = BuildDefaultSwitchSection(ctx, target);
 
-        yield return ctx.SyntaxFactory
-            .SwitchStatement(sourceExpression, caseSections, defaultSection)
+        yield return ctx.SyntaxFactory.SwitchStatement(sourceExpression, caseSections, defaultSection)
             .AddLeadingLineFeed(ctx.SyntaxFactory.Indentation);
     }
 

src/Riok.Mapperly/Descriptors/UserMethodMappingExtractor.cs

@@ -188,9 +188,9 @@ private static bool BuildGenericTypeParameters(
 
         var targetType = parameters.Target?.Type ?? methodSymbol.ReturnType.UpgradeNullable();
         var targetTypeParameter = methodSymbol.TypeParameters.FirstOrDefault(x => SymbolEqualityComparer.Default.Equals(x, targetType));
-        var sourceTypeParameter = methodSymbol
-            .TypeParameters
-            .FirstOrDefault(x => SymbolEqualityComparer.Default.Equals(x, parameters.Source.Type));
+        var sourceTypeParameter = methodSymbol.TypeParameters.FirstOrDefault(
+            x => SymbolEqualityComparer.Default.Equals(x, parameters.Source.Type)
+        );
 
         var expectedTypeParametersCount = 0;
         if (targetTypeParameter != null)
@@ -317,9 +317,9 @@ private static bool BuildParameters(
 
     private static MethodParameter? BuildReferenceHandlerParameter(SimpleMappingBuilderContext ctx, IMethodSymbol method)
     {
-        var refHandlerParameterSymbol = method
-            .Parameters
-            .FirstOrDefault(p => ctx.SymbolAccessor.HasAttribute<ReferenceHandlerAttribute>(p));
+        var refHandlerParameterSymbol = method.Parameters.FirstOrDefault(
+            p => ctx.SymbolAccessor.HasAttribute<ReferenceHandlerAttribute>(p)
+        );
         if (refHandlerParameterSymbol == null)
             return null;