Writing type names to buffer during translation

Author: SteveWilkes

ReadableExpressions/Extensions/InternalTypeExtensions.cs

@@ -1,34 +1,45 @@
-namespace AgileObjects.ReadableExpressions.Extensions
+using System.Linq;
+
+namespace AgileObjects.ReadableExpressions.Extensions
 {
+    using System;
     using System.Collections.Generic;
 
     internal static class InternalTypeExtensions
     {
-        private static readonly Dictionary<string, string> _typeNameSubstitutions = new Dictionary<string, string>
+        private static readonly Dictionary<Type, string> _typeNameSubstitutions = new Dictionary<Type, string>
         {
-            { typeof(byte).FullName, "byte" },
-            { typeof(sbyte).FullName, "sbyte" },
-            { typeof(char).FullName, "char" },
-            { typeof(bool).FullName, "bool" },
-            { typeof(short).FullName, "short" },
-            { typeof(ushort).FullName, "ushort" },
-            { typeof(int).FullName, "int" },
-            { typeof(uint).FullName, "uint" },
-            { typeof(long).FullName, "long" },
-            { typeof(ulong).FullName, "ulong" },
-            { typeof(float).FullName, "float" },
-            { typeof(decimal).FullName, "decimal" },
-            { typeof(double).FullName, "double" },
-            { typeof(string).FullName, "string" },
-            { typeof(object).FullName, "object" },
+            { typeof(string), "string" },
+            { typeof(int), "int" },
+            { typeof(bool), "bool" },
+            { typeof(decimal), "decimal" },
+            { typeof(long), "long" },
+            { typeof(double), "double" },
+            { typeof(object), "object" },
+            { typeof(byte), "byte" },
+            { typeof(short), "short" },
+            { typeof(float), "float" },
+            { typeof(char), "char" },
+            { typeof(uint), "uint" },
+            { typeof(ulong), "ulong" },
+            { typeof(sbyte), "sbyte" },
+            { typeof(ushort), "ushort" },
         };
 
         internal static ICollection<string> TypeNames => _typeNameSubstitutions.Values;
 
-        public static string GetSubstitutionOrNull(this string typeFullName)
+        public static string GetSubstitutionOrNull(this Type type)
         {
-            return _typeNameSubstitutions.TryGetValue(typeFullName, out var substitutedName)
+            return _typeNameSubstitutions.TryGetValue(type, out var substitutedName)
                 ? substitutedName : null;
         }
+
+        public static string GetSubstitutionOrNull(this string typeFullName)
+        {
+            var matchingType = _typeNameSubstitutions
+                .FirstOrDefault(kvp => kvp.Key.FullName == typeFullName);
+
+            return matchingType.Value;
+        }
     }
 }

ReadableExpressions/Extensions/PublicTypeExtensions.cs

@@ -1,4 +1,6 @@
-namespace AgileObjects.ReadableExpressions.Extensions
+using AgileObjects.ReadableExpressions.Translations;
+
+namespace AgileObjects.ReadableExpressions.Extensions
 {
     using System;
     using System.Collections;
@@ -29,59 +31,120 @@ internal static string GetFriendlyName(this Type type, TranslationSettings trans
                 return null;
             }
 
+            var buffer = new TranslationBuffer(type.FullName.Length);
+
+            buffer.WriteFriendlyName(type, translationSettings);
+
+            return buffer.GetContent();
+        }
+
+        internal static void WriteFriendlyName(
+            this TranslationBuffer buffer,
+            Type type,
+            TranslationSettings settings)
+        {
+            if (type.FullName == null)
+            {
+                // An open generic parameter Type:
+                return;
+            }
+
             if (type.IsArray)
             {
-                return type.GetElementType().GetFriendlyName(translationSettings) + "[]";
+                buffer.WriteFriendlyName(type.GetElementType(), settings);
+                buffer.WriteToTranslation("[]");
+                return;
             }
 
             if (!type.IsGenericType())
             {
-                var substitutedTypeName = type.FullName.GetSubstitutionOrNull();
-                var qualifiedTypeName = substitutedTypeName ?? type.Name;
+                var substitutedTypeName = type.GetSubstitutionOrNull();
 
                 if (type.IsNested)
                 {
-                    return type.DeclaringType.GetFriendlyName(translationSettings) + "." + qualifiedTypeName;
+                    buffer.WriteFriendlyName(type.DeclaringType, settings);
+                    buffer.WriteToTranslation('.');
+                    buffer.WriteToTranslation(substitutedTypeName ?? type.Name);
+                    return;
+                }
+
+                if (substitutedTypeName != null)
+                {
+                    buffer.WriteToTranslation(substitutedTypeName);
+                    return;
                 }
 
-                return (substitutedTypeName == null)
-                    ? GetFinalisedTypeName(type, qualifiedTypeName, translationSettings)
-                    : qualifiedTypeName;
+                buffer.WriteTypeNamespaceIfRequired(type, settings);
+                buffer.WriteToTranslation(type.Name);
+                return;
             }
 
             Type underlyingNullableType;
 
-            if ((underlyingNullableType = Nullable.GetUnderlyingType(type)) != null)
+            if ((underlyingNullableType = Nullable.GetUnderlyingType(type)) == null)
             {
-                return underlyingNullableType.GetFriendlyName(translationSettings) + "?";
+                buffer.WriteGenericTypeName(type, settings);
+                return;
             }
 
-            return GetGenericTypeName(type, translationSettings);
+            buffer.WriteFriendlyName(underlyingNullableType, settings);
+            buffer.WriteToTranslation('?');
         }
 
-        private static string GetGenericTypeName(Type genericType, TranslationSettings settings)
+        private static void WriteTypeNamespaceIfRequired(
+            this TranslationBuffer buffer,
+            Type type,
+            TranslationSettings settings)
+        {
+            if (!settings.FullyQualifyTypeNames || (type.Namespace == null))
+            {
+                return;
+            }
+
+            buffer.WriteToTranslation(type.Namespace);
+            buffer.WriteToTranslation('.');
+        }
+
+        private static void WriteGenericTypeName(
+            this TranslationBuffer buffer,
+            Type genericType,
+            TranslationSettings settings)
         {
             var typeGenericTypeArguments = genericType.GetGenericTypeArguments();
-            var genericTypeName = GetClosedGenericTypeName(genericType, ref typeGenericTypeArguments, settings);
 
             if (!genericType.IsNested)
             {
-                return GetFinalisedTypeName(genericType, genericTypeName, settings);
+                buffer.WriteTypeNamespaceIfRequired(genericType, settings);
+                buffer.WriteClosedGenericTypeName(genericType, ref typeGenericTypeArguments, settings);
+                return;
             }
 
+            var types = new List<Type> { genericType };
+
             // ReSharper disable once PossibleNullReferenceException
             while (genericType.IsNested)
             {
                 genericType = genericType.DeclaringType;
-                var parentTypeName = GetClosedGenericTypeName(genericType, ref typeGenericTypeArguments, settings);
-
-                genericTypeName = parentTypeName + "." + genericTypeName;
+                types.Add(genericType);
             }
 
-            return GetFinalisedTypeName(genericType, genericTypeName, settings);
+            buffer.WriteTypeNamespaceIfRequired(genericType, settings);
+
+            for (var i = types.Count; ;)
+            {
+                buffer.WriteClosedGenericTypeName(types[--i], ref typeGenericTypeArguments, settings);
+
+                if (i == 0)
+                {
+                    return;
+                }
+
+                buffer.WriteToTranslation('.');
+            }
         }
 
-        private static string GetClosedGenericTypeName(
+        private static void WriteClosedGenericTypeName(
+            this TranslationBuffer buffer,
             Type genericType,
             ref Type[] typeGenericTypeArguments,
             TranslationSettings settings)
@@ -92,7 +155,8 @@ private static string GetClosedGenericTypeName(
 
             if (backtickIndex == -1)
             {
-                return typeName;
+                buffer.WriteToTranslation(typeName);
+                return;
             }
 
             var numberOfParameters = int.Parse(typeName.Substring(backtickIndex + 1));
@@ -102,79 +166,93 @@ private static string GetClosedGenericTypeName(
             if (numberOfParameters == typeGenericTypeArguments.Length)
             {
                 typeArguments = typeGenericTypeArguments;
+                goto WriteName;
             }
-            else
+
+            switch (numberOfParameters)
             {
-                typeArguments = new Type[numberOfParameters];
-                var numberOfRemainingTypeArguments = typeGenericTypeArguments.Length - numberOfParameters;
-                var typeGenericTypeArgumentsSubset = new Type[numberOfRemainingTypeArguments];
-
-                Array.Copy(
-                    typeGenericTypeArguments,
-                    numberOfRemainingTypeArguments,
-                    typeArguments,
-                    0,
-                    numberOfParameters);
-
-                Array.Copy(
-                    typeGenericTypeArguments,
-                    0,
-                    typeGenericTypeArgumentsSubset,
-                    0,
-                    numberOfRemainingTypeArguments);
-
-                typeGenericTypeArguments = typeGenericTypeArgumentsSubset;
+                case 1:
+                    typeArguments = new[] { typeGenericTypeArguments[0] };
+                    break;
+
+                case 2:
+                    typeArguments = new[] { typeGenericTypeArguments[0], typeGenericTypeArguments[1] };
+                    break;
+
+                default:
+                    typeArguments = new Type[numberOfParameters];
+
+                    Array.Copy(
+                        typeGenericTypeArguments,
+                        typeArguments,
+                        numberOfParameters);
+
+                    break;
             }
 
-            return GetGenericTypeName(genericType, numberOfParameters, typeArguments, settings);
+            var numberOfRemainingTypeArguments = typeGenericTypeArguments.Length - numberOfParameters;
+            var typeGenericTypeArgumentsSubset = new Type[numberOfRemainingTypeArguments];
+
+            Array.Copy(
+                typeGenericTypeArguments,
+                numberOfParameters,
+                typeGenericTypeArgumentsSubset,
+                0,
+                numberOfRemainingTypeArguments);
+
+            typeGenericTypeArguments = typeGenericTypeArgumentsSubset;
+
+            WriteName:
+            buffer.WriteGenericTypeName(genericType, numberOfParameters, typeArguments, settings);
         }
 
-        private static string GetGenericTypeName(
+        private static void WriteGenericTypeName(
+            this TranslationBuffer buffer,
             Type type,
             int numberOfParameters,
             IList<Type> typeArguments,
             TranslationSettings settings)
         {
-            var anonTypeIndex = 0;
-
             var isAnonType =
                 type.Name.StartsWith('<') &&
-               ((anonTypeIndex = type.Name.IndexOf("AnonymousType", StringComparison.Ordinal)) != -1);
+               (type.Name.IndexOf("AnonymousType", StringComparison.Ordinal)) != -1;
 
             if (isAnonType && (settings.AnonymousTypeNameFactory != null))
             {
-                return settings.AnonymousTypeNameFactory.Invoke(type);
+                buffer.WriteToTranslation(settings.AnonymousTypeNameFactory.Invoke(type));
+                return;
             }
 
-            var typeName = type.Name;
+            string typeName;
 
-            var typeGenericTypeArgumentNames = typeArguments
-                .ProjectToArray(t => GetFriendlyName(t, settings));
-
-            typeName = typeName.Replace(
-                "`" + numberOfParameters,
-                "<" + typeGenericTypeArgumentNames.Join(", ") + ">");
+            if (isAnonType)
+            {
+                typeName = "AnonymousType";
+            }
+            else
+            {
+                var parameterCountIndex = type.Name.IndexOf("`" + numberOfParameters, StringComparison.Ordinal);
+                typeName = type.Name.Substring(0, parameterCountIndex);
+            }
 
-            return isAnonType ? GetAnonymousTypeName(typeName, anonTypeIndex) : typeName;
-        }
+            buffer.WriteToTranslation(typeName);
+            buffer.WriteToTranslation('<');
 
-        private static string GetAnonymousTypeName(string typeName, int anonTypeIndex)
-        {
-            typeName = typeName.Substring(anonTypeIndex);
+            for (var i = 0; ;)
+            {
+                var typeArgument = typeArguments[i++];
 
-            var trimStartIndex = "AnonymousType".Length;
-            var argumentsStartIndex = typeName.IndexOf('<');
+                buffer.WriteFriendlyName(typeArgument, settings);
 
-            typeName = typeName.Remove(trimStartIndex, argumentsStartIndex - trimStartIndex);
+                if (i == typeArguments.Count)
+                {
+                    break;
+                }
 
-            return typeName;
-        }
+                buffer.WriteToTranslation(", ");
+            }
 
-        private static string GetFinalisedTypeName(Type type, string typeName, TranslationSettings settings)
-        {
-            return settings.FullyQualifyTypeNames && (type.Namespace != null)
-                ? type.Namespace + "." + typeName
-                : typeName;
+            buffer.WriteToTranslation('>');
         }
 
         /// <summary>
@@ -198,7 +276,7 @@ internal static string GetVariableNameInCamelCase(this Type type, TranslationSet
         public static string GetVariableNameInPascalCase(this Type type, Func<TranslationSettings, TranslationSettings> configuration = null)
             => GetVariableNameInPascalCase(type, GetTranslationSettings(configuration));
 
-        internal static string GetVariableNameInPascalCase(this Type type, TranslationSettings settings)
+        private static string GetVariableNameInPascalCase(this Type type, TranslationSettings settings)
             => GetVariableName(type, settings).ToPascalCase();
 
         private static string GetVariableName(Type type, TranslationSettings settings)