Fixing translation of nested, multiple generic argument func types

Author: SteveWilkes

ReadableExpressions.UnitTests/WhenTranslatingConstants.cs

@@ -352,6 +352,18 @@ public void ShouldTranslateAFuncWithNestedGenericParameters()
             Assert.AreEqual("Func<int?, FileInfo, Dictionary<IDictionary<FileInfo, string[]>, string>>", translated);
         }
 
+        [TestMethod]
+        public void ShouldTranslateAnActionWithMultipleNestedGenericParameters()
+        {
+            Action<Generic<GenericOne<int>, GenericTwo<long>, GenericTwo<long>>> genericAction = fileInfo => { };
+
+            var actionConstant = Expression.Constant(genericAction);
+
+            var translated = actionConstant.ToReadableString();
+
+            Assert.AreEqual("Action<Generic<GenericOne<int>, GenericTwo<long>, GenericTwo<long>>>", translated);
+        }
+
         // See https://github.com/agileobjects/ReadableExpressions/issues/5
         [TestMethod]
         public void ShouldTranslateDbNullValue()
@@ -377,6 +389,12 @@ public void ShouldTranslateAnObjectConstant()
         }
     }
 
+    internal class GenericOne<T> { }
+
+    internal class GenericTwo<T> { }
+
+    internal class Generic<T1, T2, T3> { }
+
     internal enum OddNumber
     {
         One = 1

ReadableExpressions/Translators/ConstantExpressionTranslator.cs

@@ -1,7 +1,6 @@
 namespace AgileObjects.ReadableExpressions.Translators
 {
     using System;
-    using System.Collections.Generic;
     using System.Globalization;
     using System.Linq.Expressions;
 #if NET_STANDARD
@@ -32,9 +31,7 @@ public override string Translate(Expression expression, TranslationContext conte
                 return constant.Type.GetFriendlyName() + "." + constant.Value;
             }
 
-            string translation;
-
-            if (TryTranslateByTypeCode(constant, out translation))
+            if (TryTranslateByTypeCode(constant, out var translation))
             {
                 return translation;
             }
@@ -214,17 +211,17 @@ private static bool TryGetFactoryMethodCall(
 
         private static string FormatNumeric(decimal value)
         {
-            return (value % 1).Equals(0) ? value.ToString("0") : value.ToString();
+            return (value % 1).Equals(0) ? value.ToString("0") : value.ToString(CultureInfo.CurrentCulture);
         }
 
         private static string FormatNumeric(double value)
         {
-            return (value % 1).Equals(0) ? value.ToString("0") : value.ToString();
+            return (value % 1).Equals(0) ? value.ToString("0") : value.ToString(CultureInfo.CurrentCulture);
         }
 
         private static string FormatNumeric(float value)
         {
-            return (value % 1).Equals(0) ? value.ToString("0") : value.ToString();
+            return (value % 1).Equals(0) ? value.ToString("0") : value.ToString(CultureInfo.CurrentCulture);
         }
 
         private static bool IsType(ConstantExpression constant, out string translation)
@@ -239,116 +236,116 @@ private static bool IsType(ConstantExpression constant, out string translation)
             return false;
         }
 
-        private static readonly Regex _funcMatcher = new Regex(@"^System\.(?<Type>Func|Action)`\d+\[(?<Arguments>.+)\]$");
+        private static readonly Regex _funcMatcher = new Regex(@"^System\.(?:Func|Action)`\d+\[.+\]$");
 
         private static bool IsFunc(ConstantExpression constant, out string translation)
         {
             var match = _funcMatcher.Match(constant.Value.ToString());
 
-            if (!match.Success)
+            if (match.Success)
             {
-                translation = null;
-                return false;
+                translation = ParseFuncFrom(match.Value);
+                return true;
             }
 
-            var funcType = match.Groups["Type"].Value;
-            var argumentTypes = ParseArgumentNames(match.Groups["Arguments"].Value.Split(','));
-
-            translation = GetGenericTypeName(funcType, argumentTypes);
-            return true;
+            translation = null;
+            return false;
         }
 
         #region IsFunc Helpers
 
-        private static IEnumerable<string> ParseArgumentNames(params string[] arguments)
+        private static string ParseFuncFrom(string funcString)
         {
-            for (var i = 0; i < arguments.Length; i++)
+            var symbols = new[] { '`', ',', '[', ']' };
+            var parseIndex = 0;
+            var parsedFunc = string.Empty;
+
+            while (true)
             {
-                var argument = arguments[i];
-                var genericArgumentsIndex = argument.IndexOf('`');
+                var nextSymbolIndex = funcString.IndexOfAny(symbols, parseIndex);
 
-                if (genericArgumentsIndex == -1)
+                if (nextSymbolIndex == -1)
                 {
-                    yield return GetTypeName(argument);
-                    continue;
-                }
+                    var substring = funcString.Substring(parseIndex);
 
-                if (argument.StartsWith("System.Nullable`"))
-                {
-                    yield return GetNullableTypeName(argument);
-                    continue;
+                    if (substring.Length > 0)
+                    {
+                        var typeName = GetTypeName(substring);
+
+                        parsedFunc += typeName;
+                    }
+                    break;
                 }
 
-                var genericTypeName = GetTypeName(argument.Substring(0, genericArgumentsIndex));
-                var genericTypeArgumentsStart = argument.IndexOf('[', genericArgumentsIndex) + 1;
-                argument = argument.Substring(genericTypeArgumentsStart);
-                var genericTypeArgumentsClosesNeeded = 1;
-                var genericTypeArgumentsString = argument;
+                var substringLength = nextSymbolIndex - parseIndex;
 
-                if (i == arguments.Length - 1)
+                if (substringLength > 0)
                 {
-                    genericTypeArgumentsString = RemoveFinalGenericArgumentsClose(genericTypeArgumentsString);
+                    var substring = funcString.Substring(parseIndex, substringLength);
+
+                    if (substring == "System.Nullable")
+                    {
+                        var nullableTypeIndex = parseIndex + "System.Nullable`1[".Length;
+                        var nullableTypeEndIndex = funcString.IndexOf(']', nullableTypeIndex);
+                        var nullableTypeLength = nullableTypeEndIndex - nullableTypeIndex;
+                        substring = funcString.Substring(nullableTypeIndex, nullableTypeLength);
+
+                        var typeName = GetTypeName(substring);
+
+                        parsedFunc += typeName + "?";
+                        parseIndex = nullableTypeEndIndex + 1;
+                        continue;
+                    }
+                    else
+                    {
+                        var typeName = GetTypeName(substring);
+
+                        parsedFunc += typeName;
+                        parseIndex = nextSymbolIndex + 1;
+                    }
                 }
-                else
+
+                switch (funcString[nextSymbolIndex])
                 {
-                    while (i < arguments.Length - 1)
-                    {
-                        if (argument.IndexOf('`') != -1)
-                        {
-                            ++genericTypeArgumentsClosesNeeded;
-                        }
+                    case '`':
+                        parsedFunc += "<";
+                        parseIndex = funcString.IndexOf('[', parseIndex) + 1;
+                        continue;
 
-                        argument = arguments[++i];
-                        genericTypeArgumentsString += "," + argument;
+                    case ',':
+                        parsedFunc += ", ";
 
-                        if (argument.EndsWith(']') && (argument[argument.Length - 2] != '['))
+                        if (substringLength == 0)
                         {
-                            --genericTypeArgumentsClosesNeeded;
+                            ++parseIndex;
                         }
+                        continue;
+
+                    case '[':
+                        parsedFunc += "[]";
+                        ++parseIndex;
+                        continue;
+
+                    case ']':
+                        parsedFunc += ">";
 
-                        if (genericTypeArgumentsClosesNeeded == 0)
+                        if (substringLength == 0)
                         {
-                            genericTypeArgumentsString = RemoveFinalGenericArgumentsClose(genericTypeArgumentsString);
-                            break;
+                            ++parseIndex;
                         }
-                    }
+                        break;
                 }
-
-                var genericTypeArguments = ParseArgumentNames(genericTypeArgumentsString.Split(','));
-
-                yield return GetGenericTypeName(genericTypeName, genericTypeArguments);
             }
+
+            return parsedFunc;
         }
 
         private static string GetTypeName(string typeFullName)
         {
-            if (typeFullName.EndsWith("[]", StringComparison.Ordinal))
-            {
-                return GetTypeName(typeFullName.Substring(0, typeFullName.Length - 2)) + "[]";
-            }
-
             return typeFullName.GetSubstitutionOrNull() ??
                    typeFullName.Substring(typeFullName.LastIndexOf('.') + 1);
         }
 
-        private static readonly int _nullableTypeArgumentStart = "System.Nullable`1[".Length;
-
-        private static string GetNullableTypeName(string typeFullName)
-        {
-            var nullableTypeNameLength = typeFullName.Length - _nullableTypeArgumentStart - 1;
-            var nullableTypeName = typeFullName.Substring(_nullableTypeArgumentStart, nullableTypeNameLength);
-
-            return GetTypeName(nullableTypeName) + "?";
-        }
-
-        private static string RemoveFinalGenericArgumentsClose(string genericTypeArgumentsString)
-        {
-            return genericTypeArgumentsString.Substring(0, genericTypeArgumentsString.Length - 1);
-        }
-
-        private static string GetGenericTypeName(string typeName, IEnumerable<string> arguments)
-            => $"{typeName}<{string.Join(", ", arguments)}>";
-
         #endregion
 
         private static bool IsDefault<T>(ConstantExpression constant, out string translation)