simplify conventions

src/AutoMapper/ApiCompatBaseline.txt

@@ -4,6 +4,7 @@ MembersMustExist : Member 'public System.Object System.Object AutoMapper.Context
 MembersMustExist : Member 'public System.Boolean AutoMapper.ContextCacheKey.Equals(AutoMapper.ContextCacheKey)' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Boolean AutoMapper.ContextCacheKey.op_Equality(AutoMapper.ContextCacheKey, AutoMapper.ContextCacheKey)' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Boolean AutoMapper.ContextCacheKey.op_Inequality(AutoMapper.ContextCacheKey, AutoMapper.ContextCacheKey)' does not exist in the implementation but it does exist in the contract.
+CannotSealType : Type 'AutoMapper.ExactMatchNamingConvention' is actually (has the sealed modifier) sealed in the implementation but not sealed in the contract.
 MembersMustExist : Member 'public System.String AutoMapper.ExactMatchNamingConvention.ReplaceValue(System.Text.RegularExpressions.Match)' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Text.RegularExpressions.Regex AutoMapper.ExactMatchNamingConvention.SplittingExpression.get()' does not exist in the implementation but it does exist in the contract.
 InterfacesShouldHaveSameMembers : Interface member 'public TMappingExpression AutoMapper.IMappingExpressionBase<TSource, TDestination, TMappingExpression>.AsProxy()' is present in the implementation but not in the contract.
@@ -15,14 +16,19 @@ MembersMustExist : Member 'public System.String AutoMapper.INamingConvention.Rep
 InterfacesShouldHaveSameMembers : Interface member 'public System.String[] AutoMapper.INamingConvention.Split(System.String)' is present in the implementation but not in the contract.
 InterfacesShouldHaveSameMembers : Interface member 'public System.Text.RegularExpressions.Regex AutoMapper.INamingConvention.SplittingExpression.get()' is present in the contract but not in the implementation.
 MembersMustExist : Member 'public System.Text.RegularExpressions.Regex AutoMapper.INamingConvention.SplittingExpression.get()' does not exist in the implementation but it does exist in the contract.
+InterfacesShouldHaveSameMembers : Interface member 'public System.Collections.Generic.IReadOnlyCollection<AutoMapper.Configuration.Conventions.IMemberConfiguration> AutoMapper.IProfileConfiguration.MemberConfigurations' is present in the contract but not in the implementation.
+InterfacesShouldHaveSameMembers : Interface member 'public System.Collections.Generic.IReadOnlyCollection<AutoMapper.Configuration.Conventions.IMemberConfiguration> AutoMapper.IProfileConfiguration.MemberConfigurations.get()' is present in the contract but not in the implementation.
+MembersMustExist : Member 'public System.Collections.Generic.IReadOnlyCollection<AutoMapper.Configuration.Conventions.IMemberConfiguration> AutoMapper.IProfileConfiguration.MemberConfigurations.get()' does not exist in the implementation but it does exist in the contract.
 InterfacesShouldHaveSameMembers : Interface member 'public System.Collections.Generic.IReadOnlyCollection<AutoMapper.Configuration.TypeMapConfiguration> AutoMapper.IProfileConfiguration.OpenTypeMapConfigs.get()' is present in the implementation but not in the contract.
 InterfacesShouldHaveSameMembers : Interface member 'public System.Collections.Generic.IReadOnlyCollection<AutoMapper.Configuration.ITypeMapConfiguration> AutoMapper.IProfileConfiguration.OpenTypeMapConfigs.get()' is present in the contract but not in the implementation.
 MembersMustExist : Member 'public System.Collections.Generic.IReadOnlyCollection<AutoMapper.Configuration.ITypeMapConfiguration> AutoMapper.IProfileConfiguration.OpenTypeMapConfigs.get()' does not exist in the implementation but it does exist in the contract.
 InterfacesShouldHaveSameMembers : Interface member 'public System.Collections.Generic.IReadOnlyCollection<AutoMapper.Configuration.TypeMapConfiguration> AutoMapper.IProfileConfiguration.TypeMapConfigs.get()' is present in the implementation but not in the contract.
 InterfacesShouldHaveSameMembers : Interface member 'public System.Collections.Generic.IReadOnlyCollection<AutoMapper.Configuration.ITypeMapConfiguration> AutoMapper.IProfileConfiguration.TypeMapConfigs.get()' is present in the contract but not in the implementation.
 MembersMustExist : Member 'public System.Collections.Generic.IReadOnlyCollection<AutoMapper.Configuration.ITypeMapConfiguration> AutoMapper.IProfileConfiguration.TypeMapConfigs.get()' does not exist in the implementation but it does exist in the contract.
+CannotSealType : Type 'AutoMapper.LowerUnderscoreNamingConvention' is actually (has the sealed modifier) sealed in the implementation but not sealed in the contract.
 MembersMustExist : Member 'public System.String AutoMapper.LowerUnderscoreNamingConvention.ReplaceValue(System.Text.RegularExpressions.Match)' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Text.RegularExpressions.Regex AutoMapper.LowerUnderscoreNamingConvention.SplittingExpression.get()' does not exist in the implementation but it does exist in the contract.
+CannotSealType : Type 'AutoMapper.PascalCaseNamingConvention' is actually (has the sealed modifier) sealed in the implementation but not sealed in the contract.
 MembersMustExist : Member 'public System.String AutoMapper.PascalCaseNamingConvention.ReplaceValue(System.Text.RegularExpressions.Match)' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Text.RegularExpressions.Regex AutoMapper.PascalCaseNamingConvention.SplittingExpression.get()' does not exist in the implementation but it does exist in the contract.
 CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.CompilerGeneratedAttribute' exists on 'AutoMapper.Profile.DestinationMemberNamingConvention.get()' in the contract but not the implementation.
@@ -50,8 +56,17 @@ CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'AutoMappe
 CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'AutoMapper.Configuration.Annotations.UseExistingValueAttribute' changed from '[AttributeUsageAttribute(384)]' in the contract to '[AttributeUsageAttribute(AttributeTargets.Field | AttributeTargets.Property)]' in the implementation.
 CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'AutoMapper.Configuration.Annotations.ValueConverterAttribute' changed from '[AttributeUsageAttribute(384)]' in the contract to '[AttributeUsageAttribute(AttributeTargets.Field | AttributeTargets.Property)]' in the implementation.
 CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'AutoMapper.Configuration.Annotations.ValueResolverAttribute' changed from '[AttributeUsageAttribute(384)]' in the contract to '[AttributeUsageAttribute(AttributeTargets.Field | AttributeTargets.Property)]' in the implementation.
+TypesMustExist : Type 'AutoMapper.Configuration.Conventions.DefaultName' does not exist in the implementation but it does exist in the contract.
+TypesMustExist : Type 'AutoMapper.Configuration.Conventions.IParentSourceToDestinationNameMapper' does not exist in the implementation but it does exist in the contract.
+InterfacesShouldHaveSameMembers : Interface member 'public System.Reflection.MemberInfo AutoMapper.Configuration.Conventions.ISourceToDestinationNameMapper.GetMatchingMemberInfo(AutoMapper.Internal.TypeDetails, System.Type, System.Type, System.String)' is present in the contract but not in the implementation.
+MembersMustExist : Member 'public System.Reflection.MemberInfo AutoMapper.Configuration.Conventions.ISourceToDestinationNameMapper.GetMatchingMemberInfo(AutoMapper.Internal.TypeDetails, System.Type, System.Type, System.String)' does not exist in the implementation but it does exist in the contract.
+InterfacesShouldHaveSameMembers : Interface member 'public System.Reflection.MemberInfo AutoMapper.Configuration.Conventions.ISourceToDestinationNameMapper.GetSourceMember(AutoMapper.Internal.TypeDetails, System.Type, System.Type, System.String)' is present in the implementation but not in the contract.
+TypesMustExist : Type 'AutoMapper.Configuration.Conventions.ParentSourceToDestinationNameMapper' does not exist in the implementation but it does exist in the contract.
+MembersMustExist : Member 'public System.Reflection.MemberInfo AutoMapper.Configuration.Conventions.PrePostfixName.GetMatchingMemberInfo(AutoMapper.Internal.TypeDetails, System.Type, System.Type, System.String)' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Collections.Generic.List<System.String> AutoMapper.Configuration.Conventions.PrePostfixName.Postfixes.get()' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Collections.Generic.List<System.String> AutoMapper.Configuration.Conventions.PrePostfixName.Prefixes.get()' does not exist in the implementation but it does exist in the contract.
+MembersMustExist : Member 'public AutoMapper.Configuration.Conventions.ReplaceName AutoMapper.Configuration.Conventions.ReplaceName.AddReplace(System.String, System.String)' does not exist in the implementation but it does exist in the contract.
+MembersMustExist : Member 'public System.Reflection.MemberInfo AutoMapper.Configuration.Conventions.ReplaceName.GetMatchingMemberInfo(AutoMapper.Internal.TypeDetails, System.Type, System.Type, System.String)' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Linq.Expressions.Expression System.Linq.Expressions.Expression AutoMapper.Execution.Member.Expression' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Linq.Expressions.Expression System.Linq.Expressions.Expression AutoMapper.Execution.Member.Target' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Reflection.MemberInfo System.Reflection.MemberInfo AutoMapper.Execution.Member.MemberInfo' does not exist in the implementation but it does exist in the contract.
@@ -94,4 +109,4 @@ MembersMustExist : Member 'public AutoMapper.Internal.TypePair AutoMapper.Intern
 MembersMustExist : Member 'public System.Linq.IQueryable<TDestination> AutoMapper.QueryableExtensions.Extensions.Map<TSource, TDestination>(System.Linq.IQueryable<TSource>, System.Linq.IQueryable<TDestination>, AutoMapper.IConfigurationProvider)' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Collections.Generic.IReadOnlyCollection<System.Reflection.MemberInfo> AutoMapper.QueryableExtensions.MemberVisitor.MemberPath.get()' does not exist in the implementation but it does exist in the contract.
 TypesMustExist : Type 'AutoMapper.QueryableExtensions.Impl.MemberAccessQueryMapperVisitor' does not exist in the implementation but it does exist in the contract.
-Total Issues: 95
+Total Issues: 110

src/AutoMapper/Configuration/Conventions.cs

@@ -0,0 +1,174 @@
+using AutoMapper.Internal;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Reflection;
+namespace AutoMapper.Configuration.Conventions
+{
+    public interface ISourceToDestinationNameMapper
+    {
+        MemberInfo GetSourceMember(TypeDetails sourceTypeDetails, Type destType, Type destMemberType, string nameToSearch);
+    }
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public class MemberConfiguration
+    {
+        NameSplitMember _nameSplitMember;
+        public INamingConvention SourceMemberNamingConvention { get; set; } = PascalCaseNamingConvention.Instance;
+        public INamingConvention DestinationMemberNamingConvention { get; set; } = PascalCaseNamingConvention.Instance;
+        public List<ISourceToDestinationNameMapper> NameToMemberMappers { get; } = new();
+        public bool IsMatch(ProfileMap options, TypeDetails sourceTypeDetails, Type destType, Type destMemberType, string nameToSearch, List<MemberInfo> resolvers, bool isReverseMap)
+        {
+            var matchingMemberInfo = GetSourceMember(sourceTypeDetails, destType, destMemberType, nameToSearch);
+            if (matchingMemberInfo != null)
+            {
+                resolvers.Add(matchingMemberInfo);
+                return true;
+            }
+            return nameToSearch.Length == 0 || _nameSplitMember.IsMatch(options, sourceTypeDetails, destType, destMemberType, nameToSearch, resolvers, isReverseMap);
+        }
+        public MemberInfo GetSourceMember(TypeDetails sourceTypeDetails, Type destType, Type destMemberType, string nameToSearch)
+        {
+            var sourceMember = sourceTypeDetails.GetMember(nameToSearch);
+            if (sourceMember != null)
+            {
+                return sourceMember;
+            }
+            foreach (var namedMapper in NameToMemberMappers)
+            {
+                if ((sourceMember = namedMapper.GetSourceMember(sourceTypeDetails, destType, destMemberType, nameToSearch)) != null)
+                {
+                    return sourceMember;
+                }
+            }
+            return null;
+        }
+        public void Seal()
+        {
+            var isDefault = SourceMemberNamingConvention == PascalCaseNamingConvention.Instance && DestinationMemberNamingConvention == PascalCaseNamingConvention.Instance;
+            _nameSplitMember = isDefault ? new DefaultNameSplitMember() : new ConventionsNameSplitMember();
+            _nameSplitMember.Parent = this;
+        }
+    }
+    public class PrePostfixName : ISourceToDestinationNameMapper
+    {
+        public List<string> DestinationPrefixes { get; } = new();
+        public List<string> DestinationPostfixes { get; } = new();
+        public MemberInfo GetSourceMember(TypeDetails sourceTypeDetails, Type destType, Type destMemberType, string nameToSearch)
+        {
+            MemberInfo member;
+            foreach (var possibleSourceName in TypeDetails.PossibleNames(nameToSearch, DestinationPrefixes, DestinationPostfixes))
+            {
+                if ((member = sourceTypeDetails.GetMember(possibleSourceName)) != null)
+                {
+                    return member;
+                }
+            }
+            return null;
+        }
+    }
+    public class ReplaceName : ISourceToDestinationNameMapper
+    {
+        public List<MemberNameReplacer> MemberNameReplacers { get; } = new();
+        public MemberInfo GetSourceMember(TypeDetails sourceTypeDetails, Type destType, Type destMemberType, string nameToSearch)
+        {
+            var possibleSourceNames = PossibleNames(nameToSearch);
+            if (possibleSourceNames.Length == 0)
+            {
+                return null;
+            }
+            var possibleDestNames = sourceTypeDetails.ReadAccessors.Select(mi => (mi, possibles : PossibleNames(mi.Name))).ToArray();
+            foreach (var sourceName in possibleSourceNames)
+            {
+                foreach (var (mi, possibles) in possibleDestNames)
+                {
+                    if (possibles.Contains(sourceName, StringComparer.OrdinalIgnoreCase))
+                    {
+                        return mi;
+                    }
+                }
+            }
+            return null;
+        }
+        private string[] PossibleNames(string nameToSearch) =>
+                MemberNameReplacers.Select(r => nameToSearch.Replace(r.OriginalValue, r.NewValue))
+                    .Concat(new[] { MemberNameReplacers.Aggregate(nameToSearch, (s, r) => s.Replace(r.OriginalValue, r.NewValue)), nameToSearch })
+                    .ToArray();
+    }
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public readonly record struct MemberNameReplacer(string OriginalValue, string NewValue);
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public abstract class NameSplitMember
+    {
+        public MemberConfiguration Parent { get; set; }
+        public abstract bool IsMatch(ProfileMap options, TypeDetails sourceType, Type destType, Type destMemberType, string nameToSearch, List<MemberInfo> resolvers, bool isReverseMap);
+    }
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public sealed class DefaultNameSplitMember : NameSplitMember
+    {
+        public sealed override bool IsMatch(ProfileMap options, TypeDetails sourceType, Type destType, Type destMemberType, string nameToSearch, List<MemberInfo> resolvers, bool isReverseMap)
+        {
+            MemberInfo matchingMemberInfo = null;
+            int index = 1;
+            for (; index < nameToSearch.Length; index++)
+            {
+                if (char.IsUpper(nameToSearch[index]) && Found())
+                {
+                    return true;
+                }
+            }
+            return matchingMemberInfo != null && Found();
+            bool Found()
+            {
+                var first = nameToSearch[..index];
+                matchingMemberInfo = Parent.GetSourceMember(sourceType, destType, destMemberType, first);
+                if (matchingMemberInfo == null)
+                {
+                    return false;
+                }
+                resolvers.Add(matchingMemberInfo);
+                var second = nameToSearch[index..];
+                var details = options.CreateTypeDetails(matchingMemberInfo.GetMemberType());
+                if (Parent.IsMatch(options, details, destType, destMemberType, second, resolvers, isReverseMap))
+                {
+                    return true;
+                }
+                resolvers.RemoveAt(resolvers.Count - 1);
+                return false;
+            }
+        }
+    }
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public sealed class ConventionsNameSplitMember : NameSplitMember
+    {
+        public sealed override bool IsMatch(ProfileMap options, TypeDetails sourceType, Type destType, Type destMemberType, string nameToSearch, List<MemberInfo> resolvers, bool isReverseMap)
+        {
+            var destinationMemberNamingConvention = isReverseMap ? Parent.SourceMemberNamingConvention : Parent.DestinationMemberNamingConvention;
+            var matches = destinationMemberNamingConvention.Split(nameToSearch);
+            var length = matches.Length;
+            if (length < 2)
+            {
+                return false;
+            }
+            var sourceMemberNamingConvention = isReverseMap ? Parent.DestinationMemberNamingConvention : Parent.SourceMemberNamingConvention;
+            var separator = sourceMemberNamingConvention.SeparatorCharacter;
+            for (var index = 1; index <= length; index++)
+            {
+                var first = string.Join(separator, matches, 0, index);
+                var matchingMemberInfo = Parent.GetSourceMember(sourceType, destType, destMemberType, first);
+                if (matchingMemberInfo != null)
+                {
+                    resolvers.Add(matchingMemberInfo);
+                    var second = string.Join(separator, matches, index, length - index);
+                    var details = options.CreateTypeDetails(matchingMemberInfo.GetMemberType());
+                    if (Parent.IsMatch(options, details, destType, destMemberType, second, resolvers, isReverseMap))
+                    {
+                        return true;
+                    }
+                    resolvers.RemoveAt(resolvers.Count - 1);
+                }
+            }
+            return false;
+        }
+    }
+}