drop RegEx

src/AutoMapper/ApiCompatBaseline.txt

@@ -1,13 +1,20 @@
 Compat issues with assembly AutoMapper:
 CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'AutoMapper.AutoMapAttribute' changed from '[AttributeUsageAttribute(1036, AllowMultiple=true)]' in the contract to '[AttributeUsageAttribute(AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Struct, AllowMultiple=true)]' in the implementation.
 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.
 InterfacesShouldHaveSameMembers : Interface member 'public void AutoMapper.IMappingExpressionBase<TSource, TDestination, TMappingExpression>.AsProxy()' is present in the contract but not in the implementation.
 MembersMustExist : Member 'public void AutoMapper.IMappingExpressionBase<TSource, TDestination, TMappingExpression>.AsProxy()' does not exist in the implementation but it does exist in the contract.
+InterfacesShouldHaveSameMembers : Interface member 'public System.Text.RegularExpressions.Regex AutoMapper.INamingConvention.SplittingExpression' is present in the contract but not in the implementation.
 InterfacesShouldHaveSameMembers : Interface member 'public System.String AutoMapper.INamingConvention.ReplaceValue(System.Text.RegularExpressions.Match)' is present in the contract but not in the implementation.
 MembersMustExist : Member 'public System.String AutoMapper.INamingConvention.ReplaceValue(System.Text.RegularExpressions.Match)' does not exist in the implementation but it does exist in the contract.
+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.
 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.
 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.
 MembersMustExist : Member 'public AutoMapper.IMappingOperationOptions AutoMapper.ResolutionContext.Options.get()' does not exist in the implementation but it does exist in the contract.
 TypesMustExist : Type 'AutoMapper.ValueResolverConfiguration' does not exist in the implementation but it does exist in the contract.
 InterfacesShouldHaveSameMembers : Default interface member 'public System.Boolean AutoMapper.Configuration.IPropertyMapConfiguration.Ignored' is present in the implementation but not in the contract.
@@ -32,4 +39,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: 33
+Total Issues: 40

src/AutoMapper/Configuration/Conventions/MemberConfiguration.cs

@@ -88,29 +88,26 @@ public bool MapDestinationPropertyToSource(ProfileMap options, TypeDetails sourc
         {
             var destinationMemberNamingConvention = isReverseMap ? SourceMemberNamingConvention : DestinationMemberNamingConvention;
             var sourceMemberNamingConvention = isReverseMap ? DestinationMemberNamingConvention : SourceMemberNamingConvention;
-            var matches = destinationMemberNamingConvention.SplittingExpression?.Matches(nameToSearch);
-            if (matches == null || matches.Count < 2)
+            var matches = destinationMemberNamingConvention.Split(nameToSearch);
+            var length = matches.Length;
+            var separator = sourceMemberNamingConvention.SeparatorCharacter;
+            for (var index = 1; index <= length; index++)
             {
-                return false;
-            }
-            MemberInfo matchingMemberInfo = null;
-            for (var index = 1; index <= matches.Count; index++)
-            {
-                var first = string.Join(sourceMemberNamingConvention.SeparatorCharacter, matches.Take(index).Select(m=>m.Value));
-                matchingMemberInfo = parent.NameMapper.GetMatchingMemberInfo(sourceType, destType, destMemberType, first);
+                var first = string.Join(separator, matches, 0, index);
+                var matchingMemberInfo = parent.NameMapper.GetMatchingMemberInfo(sourceType, destType, destMemberType, first);
                 if (matchingMemberInfo != null)
                 {
                     resolvers.Add(matchingMemberInfo);
                     var details = options.CreateTypeDetails(matchingMemberInfo.GetMemberType());
-                    var second = string.Join(sourceMemberNamingConvention.SeparatorCharacter, matches.Skip(index).Select(m=>m.Value));
-                    var foundMatch = parent.MapDestinationPropertyToSource(options, details, destType, destMemberType, second, resolvers, isReverseMap);
-                    if (!foundMatch)
-                        resolvers.RemoveAt(resolvers.Count - 1);
-                    else
-                        break;
+                    var second = string.Join(separator, matches, index, length - index);
+                    if (parent.MapDestinationPropertyToSource(options, details, destType, destMemberType, second, resolvers, isReverseMap))
+                    {
+                        return true;
+                    }
+                    resolvers.RemoveAt(resolvers.Count - 1);
                 }
             }
-            return matchingMemberInfo != null;
+            return false;
         }
     }
 }

src/AutoMapper/Configuration/INamingConvention.cs

@@ -1,35 +1,52 @@
-using System.Text.RegularExpressions;
+using System;
+using System.Collections.Generic;
 namespace AutoMapper
 {
     /// <summary>
     /// Defines a naming convention strategy
     /// </summary>
     public interface INamingConvention
     {
-        /// <summary>
-        /// Regular expression on how to tokenize a member
-        /// </summary>
-        Regex SplittingExpression { get; }
+        string[] Split(string input);
         string SeparatorCharacter { get; }
     }
     public class ExactMatchNamingConvention : INamingConvention
     {
         public static readonly ExactMatchNamingConvention Instance = new();
-        public Regex SplittingExpression { get; }
-        public string SeparatorCharacter => "";
+        public string[] Split(string _) => Array.Empty<string>();
+        public string SeparatorCharacter => null;
     }
     public class PascalCaseNamingConvention : INamingConvention
     {
-        private static readonly Regex PascalCase = new(@"(\p{Lu}+(?=$|\p{Lu}[\p{Ll}0-9])|\p{Lu}?[\p{Ll}0-9]+)");
         public static readonly PascalCaseNamingConvention Instance = new();
-        public Regex SplittingExpression { get; } = PascalCase;
         public string SeparatorCharacter => "";
+        public string[] Split(string input)
+        {
+            List<string> result = null;
+            int lower = 0;
+            int index = 1;
+            while (index < input.Length)
+            {
+                if (char.IsUpper(input[index]))
+                {
+                    result ??= new();
+                    result.Add(input[lower..index]);
+                    lower = index;
+                }
+                index++;
+            }
+            if (result == null)
+            {
+                return Array.Empty<string>();
+            }
+            result.Add(input[lower..index]);
+            return result.ToArray();
+        }
     }
     public class LowerUnderscoreNamingConvention : INamingConvention
     {
-        private static readonly Regex LowerUnderscore = new(@"[\p{Ll}\p{Lu}0-9]+(?=_?)");
         public static readonly LowerUnderscoreNamingConvention Instance = new();
-        public Regex SplittingExpression { get; } = LowerUnderscore;
         public string SeparatorCharacter => "_";
+        public string[] Split(string input) => input.Split('_', StringSplitOptions.RemoveEmptyEntries);
     }
 }

src/UnitTests/Internal/TypeMapFactorySpecs.cs

@@ -1,7 +1,4 @@
-using System;
-using System.Collections.Generic;
 using System.Linq;
-using System.Reflection;
 using System.Text.RegularExpressions;
 using Xunit;
 using Shouldly;
@@ -11,7 +8,6 @@ namespace AutoMapper.UnitTests.Tests
 {
     using AutoMapper.Internal;
     using System;
-    using Assembly = System.Reflection.Assembly;
 
     public class StubNamingConvention : INamingConvention
     {
@@ -26,6 +22,8 @@ public StubNamingConvention(Func<Match, string> replaceFunc)
         public Regex SplittingExpression { get; set; }
         public string SeparatorCharacter { get; set; }
 
+        public string[] Split(string input) => SplittingExpression.Matches(input).Select(m=>m.Value).ToArray();
+
         public string ReplaceValue(Match match)
         {
             return _replaceFunc(match);

src/UnitTests/ReverseMapping.cs

@@ -384,10 +384,7 @@ public class UnderscoreNamingConvention : INamingConvention
             public Regex SplittingExpression { get; } = new Regex(@"\p{Lu}[a-z0-9]*(?=_?)");
 
             public string SeparatorCharacter => "_";
-            public string ReplaceValue(Match match)
-            {
-                return match.Value;
-            }
+            public string[] Split(string input) => SplittingExpression.Matches(input).Select(m => m.Value).ToArray();
         }
 
         protected override MapperConfiguration CreateConfiguration() => new(cfg =>