fix: 正确处理条件访问与字符串内的换行

stratosblue · stratosblue · commit 29b0438d5745 · 2024-07-08T20:28:33.000+08:00
diff --git a/Directory.Build.props b/Directory.Build.props
@@ -10,7 +10,7 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <Version>1.0.0</Version>
+    <Version>1.0.1</Version>
 
     <Description>Code fix provider for `C#` code log diagnosis `CA1727`, `CA2253`, `CA2254`. 针对 `C#` 代码日志诊断 `CA1727`, `CA2253`, `CA2254` 的代码修复提供程序</Description>
 
diff --git a/src/Cuture.CodeAnalysis.LoggingCodeFixes/LoggingInvocationFixer.cs b/src/Cuture.CodeAnalysis.LoggingCodeFixes/LoggingInvocationFixer.cs
@@ -4,14 +4,14 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
+using static Cuture.CodeAnalysis.LoggingCodeFixes.PlaceHolderNormalizer;
+
 namespace Cuture.CodeAnalysis.LoggingCodeFixes;
 
 public static class LoggingInvocationFixer
 {
     #region Private 字段
 
-    private static readonly Regex s_ignoreRegex = new("\\.|\\(.*?\\)|\\[.*?\\]|this\\.|This\\.", RegexOptions.Compiled);
-
     private static readonly Regex s_numericPlaceHolderRegex = new("\\{[\\d ]+\\}", RegexOptions.Compiled);
 
     private static readonly Regex s_placeHolderRegex = new("(?<=\\{)(.+?)(?=\\})", RegexOptions.Compiled);
@@ -93,7 +93,7 @@ public static async Task<Document> FixNumericPlaceHolderAsync(Document document,
 
             var arguments = invocationExpressionSyntax.ArgumentList.Arguments.ToList();
             arguments = arguments.SkipWhile(m => !ReferenceEquals(stringArgument, m)).Skip(1).ToList();
-            var text = syntaxToken.ValueText;
+            var text = syntaxToken.Text.Trim('"');
 
             var index = 0;
 
@@ -113,7 +113,7 @@ public static async Task<Document> FixNumericPlaceHolderAsync(Document document,
                                 break;
 
                             case MemberAccessExpressionSyntax invocationMemberAccessExpressionSyntax:
-                                result = CreatePlaceHolderName(invocationMemberAccessExpressionSyntax.ToString()) ?? match.Value;
+                                result = Normalize(invocationMemberAccessExpressionSyntax.ToString()) ?? match.Value;
                                 break;
                         }
                         break;
@@ -123,11 +123,15 @@ public static async Task<Document> FixNumericPlaceHolderAsync(Document document,
                         break;
 
                     case LiteralExpressionSyntax literalExpressionSyntax:
-                        result = CreatePlaceHolderName(semanticModel.GetTypeInfo(literalExpressionSyntax).Type.Name) ?? match.Value;
+                        result = Normalize(semanticModel.GetTypeInfo(literalExpressionSyntax).Type.Name) ?? match.Value;
                         break;
 
                     case MemberAccessExpressionSyntax memberAccessExpressionSyntax:
-                        result = CreatePlaceHolderName(memberAccessExpressionSyntax.ToString()) ?? match.Value;
+                        result = Normalize(memberAccessExpressionSyntax.ToString()) ?? match.Value;
+                        break;
+
+                    case ConditionalAccessExpressionSyntax conditionalAccessExpressionSyntax:
+                        result = Normalize(conditionalAccessExpressionSyntax.ToString()) ?? match.Value;
                         break;
                 }
                 return $"{{{result}}}";
@@ -154,7 +158,7 @@ public static async Task<Document> FixPascalCasePlaceHolderAsync(Document docume
 
             text = s_placeHolderRegex.Replace(text, match =>
             {
-                return CreatePlaceHolderName(match.Value);
+                return Normalize(match.Value);
             });
 
             var newExpressionSyntax = CreateLiteralExpressionSyntax($"\"{text}\"");
@@ -175,27 +179,7 @@ public static async Task<Document> FixPascalCasePlaceHolderAsync(Document docume
 
     private static InterpolatedStringTextSyntax CreateHolderInterpolatedStringTextSyntax(string valueText)
     {
-        return CreateInterpolatedStringTextSyntax($"{{{{{CreatePlaceHolderName(valueText)}}}}}");
-    }
-
-    private static string CreatePlaceHolderName(string valueText)
-    {
-        var valueSpan = valueText.AsSpan()
-                                 .Trim()
-                                 .TrimStart('{')
-                                 .TrimStart('@')
-                                 .TrimStart('_')
-                                 .TrimEnd('}')
-                                 .Trim();
-
-        var index = 0;
-        Span<char> newSpan = new char[valueSpan.Length + 4];
-        var firstChar = valueSpan[0];
-        newSpan[index++] = char.IsLetter(firstChar) ? char.ToUpper(firstChar) : firstChar;
-        valueSpan.Slice(1).CopyTo(newSpan.Slice(index));
-        index += valueSpan.Length - 1;
-
-        return s_ignoreRegex.Replace(newSpan.Slice(0, index).ToString(), "");
+        return CreateInterpolatedStringTextSyntax($"{{{{{Normalize(valueText)}}}}}");
     }
 
     private static IEnumerable<InterpolatedStringContentSyntaxDescriptor> EnumerateProcessedInterpolatedStringContentSyntaxes(IEnumerable<InterpolatedStringContentSyntax> contentSyntaxes)
@@ -269,12 +253,12 @@ private static IEnumerable<InterpolatedStringContentSyntaxDescriptor> EnumerateP
             if (identifierNameSyntax.Parent is InvocationExpressionSyntax invocationExpressionSyntax)
             {
                 var text = invocationExpressionSyntax.ArgumentList.Arguments[0].Expression.ToString();
-                return CreatePlaceHolderName(text);
+                return Normalize(text);
             }
         }
         else
         {
-            return CreatePlaceHolderName(identifierNameSyntax.Identifier.ValueText);
+            return Normalize(identifierNameSyntax.Identifier.ValueText);
         }
         return null;
     }
diff --git a/src/Cuture.CodeAnalysis.LoggingCodeFixes/PlaceHolderNormalizer.cs b/src/Cuture.CodeAnalysis.LoggingCodeFixes/PlaceHolderNormalizer.cs
@@ -0,0 +1,77 @@
+﻿using System.Buffers;
+using System.Text.RegularExpressions;
+
+namespace Cuture.CodeAnalysis.LoggingCodeFixes;
+
+/// <summary>
+/// 占位符规范化器
+/// </summary>
+public class PlaceHolderNormalizer
+{
+    #region Private 字段
+
+    private static readonly Regex s_normalizeRegex = new("\\?|\\.|\\(.*?\\)|\\[.*?\\]|this\\.|This\\.|@", RegexOptions.Compiled);
+
+    private static readonly char[] s_shouldUpperFollowChars = ['.', '@'];
+
+    private static ReadOnlySpan<char> ShouldUpperFollowChars => s_shouldUpperFollowChars;
+
+    #endregion Private 字段
+
+    #region Public 方法
+
+    /// <summary>
+    /// 创建规范化的占位符
+    /// </summary>
+    /// <param name="input"></param>
+    /// <returns></returns>
+    public static string Normalize(string input) => Normalize(input.AsSpan());
+
+    /// <summary>
+    /// 创建规范化的占位符
+    /// </summary>
+    /// <param name="input"></param>
+    /// <returns></returns>
+    public static string Normalize(ReadOnlySpan<char> input)
+    {
+        input = input.Trim()
+                     .TrimStart('{')
+                     .TrimStart('@')
+                     .TrimStart('_')
+                     .TrimEnd('}')
+                     .Trim();
+
+        var bufferLength = 0;
+        var buffer = ArrayPool<char>.Shared.Rent(input.Length + 4);
+        try
+        {
+            Span<char> newSpan = buffer;
+            var firstChar = input[0];
+            newSpan[bufferLength++] = char.ToUpper(firstChar);
+            input.Slice(1).CopyTo(newSpan.Slice(bufferLength));
+            bufferLength += input.Length - 1;
+
+            var index = 0;
+            while (newSpan.Slice(index).IndexOfAny(ShouldUpperFollowChars) is { } nextIndex
+                   && nextIndex >= 0)
+            {
+                nextIndex = nextIndex + index + 1;
+                if (nextIndex >= newSpan.Length)
+                {
+                    break;
+                }
+
+                newSpan[nextIndex] = char.ToUpper(newSpan[nextIndex]);
+                index = nextIndex;
+            }
+
+            return s_normalizeRegex.Replace(newSpan.Slice(0, bufferLength).ToString(), "");
+        }
+        finally
+        {
+            ArrayPool<char>.Shared.Return(buffer);
+        }
+    }
+
+    #endregion Public 方法
+}
diff --git a/test/Cuture.CodeAnalysis.LoggingCodeFixes.Test/NumericPlaceHolderFixTest.cs b/test/Cuture.CodeAnalysis.LoggingCodeFixes.Test/NumericPlaceHolderFixTest.cs
@@ -10,6 +10,158 @@ public class NumericPlaceHolderFixTest
 {
     #region Public 方法
 
+    [TestMethod]
+    public async Task Should_BeginLine_NewLine_Retain()
+    {
+        LoggingCodeTemplate test =
+            @"
+            var type = _logger.GetType();
+            _logger.LogInformation({|#0:""\r\nValue: {1}""|}, type?.Name);
+            ";
+
+        LoggingCodeTemplate fixtest =
+            @"
+            var type = _logger.GetType();
+            _logger.LogInformation(""\r\nValue: {TypeName}"", type?.Name);
+            ";
+
+        var expected = GetExpected();
+        await VerifyCS.VerifyCodeFixAsync(test, expected, fixtest);
+    }
+
+    [TestMethod]
+    public async Task Should_ConditionalAccess_Replace_With_Memeber_Name()
+    {
+        LoggingCodeTemplate test =
+            """
+            var type = _logger.GetType();
+            _logger.LogInformation({|#0:"Value: {1}"|}, type?.Name);
+            """;
+
+        LoggingCodeTemplate fixtest =
+            """
+            var type = _logger.GetType();
+            _logger.LogInformation("Value: {TypeName}", type?.Name);
+            """;
+
+        var expected = GetExpected();
+        await VerifyCS.VerifyCodeFixAsync(test, expected, fixtest);
+    }
+
+    [TestMethod]
+    public async Task Should_ConditionalAccess_Replace_With_Memeber_Name_ML()
+    {
+        LoggingCodeTemplate test =
+            """
+            var type = _logger.GetType();
+            _logger.LogInformation({|#0:"Value: {1}"|}, type?.Assembly?.EntryPoint?.Name);
+            """;
+
+        LoggingCodeTemplate fixtest =
+            """
+            var type = _logger.GetType();
+            _logger.LogInformation("Value: {TypeAssemblyEntryPointName}", type?.Assembly?.EntryPoint?.Name);
+            """;
+
+        var expected = GetExpected();
+        await VerifyCS.VerifyCodeFixAsync(test, expected, fixtest);
+    }
+
+    [TestMethod]
+    public async Task Should_ConditionalAccess_Replace_With_Method_Name()
+    {
+        LoggingCodeTemplate test =
+            """
+            var ex = new Exception();
+            _logger.LogInformation({|#0:"Value: {1}"|}, ex?.GetType());
+            """;
+
+        LoggingCodeTemplate fixtest =
+            """
+            var ex = new Exception();
+            _logger.LogInformation("Value: {ExGetType}", ex?.GetType());
+            """;
+
+        var expected = GetExpected();
+        await VerifyCS.VerifyCodeFixAsync(test, expected, fixtest);
+    }
+
+    [TestMethod]
+    public async Task Should_ConditionalAccess_Replace_With_Method_Name_ML()
+    {
+        LoggingCodeTemplate test =
+            """
+            var ex = new Exception();
+            _logger.LogInformation({|#0:"Value: {1}"|}, ex?.GetType()?.GetProperties()?.GetHashCode());
+            """;
+
+        LoggingCodeTemplate fixtest =
+            """
+            var ex = new Exception();
+            _logger.LogInformation("Value: {ExGetTypeGetPropertiesGetHashCode}", ex?.GetType()?.GetProperties()?.GetHashCode());
+            """;
+
+        var expected = GetExpected();
+        await VerifyCS.VerifyCodeFixAsync(test, expected, fixtest);
+    }
+
+    [TestMethod]
+    public async Task Should_EndLine_NewLine_Retain()
+    {
+        LoggingCodeTemplate test =
+            @"
+            var type = _logger.GetType();
+            _logger.LogInformation({|#0:""Value: {1}\r\n""|}, type?.Name);
+            ";
+
+        LoggingCodeTemplate fixtest =
+            @"
+            var type = _logger.GetType();
+            _logger.LogInformation(""Value: {TypeName}\r\n"", type?.Name);
+            ";
+
+        var expected = GetExpected();
+        await VerifyCS.VerifyCodeFixAsync(test, expected, fixtest);
+    }
+
+    [TestMethod]
+    public async Task Should_MidLine_NewLine_Retain()
+    {
+        LoggingCodeTemplate test =
+            @"
+            var type = _logger.GetType();
+            _logger.LogInformation({|#0:""Value: {1}\r\n{2}""|}, type?.Name, type);
+            ";
+
+        LoggingCodeTemplate fixtest =
+            @"
+            var type = _logger.GetType();
+            _logger.LogInformation(""Value: {TypeName}\r\n{Type}"", type?.Name, type);
+            ";
+
+        var expected = GetExpected();
+        await VerifyCS.VerifyCodeFixAsync(test, [expected, expected], fixtest);
+    }
+
+    [TestMethod]
+    public async Task Should_Multi_NewLine_Retain()
+    {
+        LoggingCodeTemplate test =
+            @"
+            var type = _logger.GetType();
+            _logger.LogInformation({|#0:""Value\r\n: {1}\r\n{2}\r\n""|}, type?.Name, type);
+            ";
+
+        LoggingCodeTemplate fixtest =
+            @"
+            var type = _logger.GetType();
+            _logger.LogInformation(""Value\r\n: {TypeName}\r\n{Type}\r\n"", type?.Name, type);
+            ";
+
+        var expected = GetExpected();
+        await VerifyCS.VerifyCodeFixAsync(test, [expected, expected], fixtest);
+    }
+
     [TestMethod]
     public async Task Should_Replace_With_Memeber_Name()
     {
@@ -131,14 +283,14 @@ public async Task Should_Success()
             """
             var type = _logger.GetType();
             var ex = new Exception();
-            _logger.LogInformation({|#0:"Value: {1} {2} {3} {4}"|}, nameof(ex), type.Assembly.EntryPoint.Name, ex.GetType().GetProperties().GetHashCode(), type);
+            _logger.LogInformation({|#0:"Value: {1} {2} {3} {4}"|}, nameof(ex), type.Assembly?.EntryPoint.Name, ex.GetType().GetProperties()?.GetHashCode(), type);
             """;
 
         LoggingCodeTemplate fixtest =
             """
             var type = _logger.GetType();
             var ex = new Exception();
-            _logger.LogInformation("Value: {Ex} {TypeAssemblyEntryPointName} {ExGetTypeGetPropertiesGetHashCode} {Type}", nameof(ex), type.Assembly.EntryPoint.Name, ex.GetType().GetProperties().GetHashCode(), type);
+            _logger.LogInformation("Value: {Ex} {TypeAssemblyEntryPointName} {ExGetTypeGetPropertiesGetHashCode} {Type}", nameof(ex), type.Assembly?.EntryPoint.Name, ex.GetType().GetProperties()?.GetHashCode(), type);
             """;
 
         var expected = GetExpected();
diff --git a/test/Cuture.CodeAnalysis.LoggingCodeFixes.Test/PascalCasePlaceHolderFixTest.cs b/test/Cuture.CodeAnalysis.LoggingCodeFixes.Test/PascalCasePlaceHolderFixTest.cs
@@ -32,6 +32,28 @@ public async Task Should_Success()
         await VerifyCS.VerifyCodeFixAsync(test, [expected, expected, expected, expected], fixtest);
     }
 
+    [TestMethod]
+    public async Task Should_Success_With_ConditionalAccess()
+    {
+        LoggingCodeTemplate test =
+            """
+            var type = _logger.GetType();
+            var ex = new Exception();
+            _logger.LogInformation({|#0:"Value: {ex} {typeAssemblyEntryPointName} {exGetTypeGetPropertiesGetHashCode} {type}"|}, nameof(ex), type?.Assembly?.EntryPoint?.Name, ex?.GetType()?.GetProperties()?.GetHashCode(), type);
+            """;
+
+        LoggingCodeTemplate fixtest =
+            """
+            var type = _logger.GetType();
+            var ex = new Exception();
+            _logger.LogInformation("Value: {Ex} {TypeAssemblyEntryPointName} {ExGetTypeGetPropertiesGetHashCode} {Type}", nameof(ex), type?.Assembly?.EntryPoint?.Name, ex?.GetType()?.GetProperties()?.GetHashCode(), type);
+            """;
+
+        var expected = GetExpected();
+
+        await VerifyCS.VerifyCodeFixAsync(test, [expected, expected, expected, expected], fixtest);
+    }
+
     #endregion Public 方法
 
     #region Private 方法
diff --git a/test/Cuture.CodeAnalysis.LoggingCodeFixes.Test/PlaceHolderNormalizerTest.cs b/test/Cuture.CodeAnalysis.LoggingCodeFixes.Test/PlaceHolderNormalizerTest.cs
