Simplify replacement of error type names with inferred names

Change approach to use `ToDisplayParts`, which removes the need for regex parsing of generated code

Author: simonmckenzie

AutomaticInterface/AutomaticInterface/RoslynExtensions.cs

@@ -86,104 +86,64 @@ public static string ToDisplayString(
             this IParameterSymbol symbol,
             SymbolDisplayFormat displayFormat,
             List<string> generatedInterfaceNames
-        )
-        {
-            var parameterDisplayString = symbol.ToDisplayString(displayFormat);
-
-            var parameterTypeDisplayString = symbol.Type.ToDisplayString(
-                displayFormat,
-                generatedInterfaceNames
-            );
+        ) => ToDisplayString((ISymbol)symbol, displayFormat, generatedInterfaceNames);
 
-            // Replace the type part of the parameter definition - we don't try to generate the whole parameter definition
-            // as it's quite complex - we leave that to Roslyn.
-            return ParameterTypeMatcher.Replace(parameterDisplayString, parameterTypeDisplayString);
-        }
-
-        /// <summary>
-        /// Matches the type part of a parameter definition (Type name[ = defaultValue])
-        /// </summary>
-        private static readonly Regex ParameterTypeMatcher =
-            new(@"[^\s=]+(?=\s\S+(\s?=\s?\S+)?$)", RegexOptions.Compiled);
-
-        /// <summary>
-        /// Wraps <see cref="ITypeSymbol.ToDisplayString(Microsoft.CodeAnalysis.SymbolDisplayFormat?)" /> with custom resolution for generated types
-        /// </summary>
-        /// <returns></returns>
         public static string ToDisplayString(
             this ITypeSymbol symbol,
             SymbolDisplayFormat displayFormat,
             List<string> generatedInterfaceNames
-        )
-        {
-            var builder = new StringBuilder();
-
-            AppendTypeSymbolDisplayString(symbol, displayFormat, generatedInterfaceNames, builder);
+        ) => ToDisplayString((ISymbol)symbol, displayFormat, generatedInterfaceNames);
 
-            return builder.ToString();
-        }
-
-        private static void AppendTypeSymbolDisplayString(
-            ITypeSymbol typeSymbol,
+        /// <summary>
+        /// Wraps <see cref="ITypeSymbol.ToDisplayString(Microsoft.CodeAnalysis.SymbolDisplayFormat?)" /> with custom resolution for generated types
+        /// </summary>
+        private static string ToDisplayString(
+            this ISymbol symbol,
             SymbolDisplayFormat displayFormat,
-            List<string> generatedInterfaceNames,
-            StringBuilder builder
+            List<string> generatedInterfaceNames
         )
         {
-            if (typeSymbol is not IErrorTypeSymbol errorTypeSymbol)
-            {
-                // This symbol contains no unresolved types. Fall back to the default generation provided by Roslyn
-                builder.Append(typeSymbol.ToDisplayString(displayFormat));
-                return;
-            }
+            var displayStringBuilder = new StringBuilder();
 
-            var symbolName =
-                InferGeneratedInterfaceName(errorTypeSymbol, generatedInterfaceNames)
-                ?? errorTypeSymbol.Name;
+            var displayParts = symbol.ToDisplayParts(displayFormat);
 
-            builder.Append(symbolName);
-
-            if (errorTypeSymbol.IsGenericType)
+            foreach (var part in displayParts)
             {
-                builder.Append('<');
-
-                bool isFirstTypeArgument = true;
-                foreach (var typeArgument in errorTypeSymbol.TypeArguments)
+                if (part.Kind == SymbolDisplayPartKind.ErrorTypeName)
                 {
-                    if (!isFirstTypeArgument)
-                    {
-                        builder.Append(", ");
-                    }
-
-                    AppendTypeSymbolDisplayString(
-                        typeArgument,
-                        displayFormat,
-                        generatedInterfaceNames,
-                        builder
+                    var unrecognisedName = part.ToString();
+
+                    var inferredName = ReplaceWithInferredInterfaceName(
+                        unrecognisedName,
+                        generatedInterfaceNames
                     );
 
-                    isFirstTypeArgument = false;
+                    displayStringBuilder.Append(inferredName);
+                }
+                else
+                {
+                    displayStringBuilder.Append(part.ToString());
                 }
-
-                builder.Append('>');
             }
+
+            return displayStringBuilder.ToString();
         }
 
-        private static string? InferGeneratedInterfaceName(
-            IErrorTypeSymbol unrecognisedSymbol,
+        private static string ReplaceWithInferredInterfaceName(
+            string unrecognisedName,
             List<string> generatedInterfaceNames
         )
         {
             var matches = generatedInterfaceNames
-                .Where(name => Regex.IsMatch(name, $"[.:]{unrecognisedSymbol.Name}$"))
+                .Where(name => Regex.IsMatch(name, $"[.:]{unrecognisedName}$"))
                 .ToList();
 
             if (matches.Count != 1)
             {
                 // Either there's no match or an ambiguous match - we can't safely infer the interface name.
                 // This is very much a "best effort" approach - if there are two interfaces with the same name,
                 // there's no obvious way to work out which one the symbol is referring to.
-                return null;
+                return unrecognisedName;
             }
 
             return matches[0];