feat: Implement CodeFixProvider for PH2145 with comprehensive test coverage for 80%+ coverage

Documentation/Diagnostics/PH2145.md

@@ -6,7 +6,7 @@
 | Diagnostic ID | PH2145 |
 | Category  | [Maintainability](../Maintainability.md) |
 | Analyzer | [AvoidStringFormatInInterpolatedStringAnalyzer](https://github.com/philips-software/roslyn-analyzers/blob/main/Philips.CodeAnalysis.MaintainabilityAnalyzers/Maintainability/AvoidStringFormatInInterpolatedStringAnalyzer.cs)
-| CodeFix  | No |
+| CodeFix  | Yes |
 | Severity | Info |
 | Enabled By Default | No |
 

Philips.CodeAnalysis.MaintainabilityAnalyzers/Maintainability/AvoidStringFormatInInterpolatedStringAnalyzer.cs

@@ -58,4 +58,4 @@ private bool ContainsStringFormatCall(ExpressionSyntax expression)
 			return false;
 		}
 	}
-}
+}

Philips.CodeAnalysis.MaintainabilityAnalyzers/Maintainability/AvoidStringFormatInInterpolatedStringCodeFixProvider.cs

@@ -0,0 +1,198 @@
+// © 2025 Koninklijke Philips N.V. See License.md in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Composition;
+using System.Globalization;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Philips.CodeAnalysis.Common;
+
+namespace Philips.CodeAnalysis.MaintainabilityAnalyzers.Maintainability
+{
+	[ExportCodeFixProvider(LanguageNames.CSharp,
+		Name = nameof(AvoidStringFormatInInterpolatedStringCodeFixProvider)), Shared]
+	public class AvoidStringFormatInInterpolatedStringCodeFixProvider :
+		SingleDiagnosticCodeFixProvider<InterpolationSyntax>
+	{
+		protected override string Title => "Remove redundant string.Format call";
+
+		protected override DiagnosticId DiagnosticId =>
+			DiagnosticId.AvoidStringFormatInInterpolatedString;
+
+		protected override async Task<Document> ApplyFix(Document document, InterpolationSyntax node,
+			ImmutableDictionary<string, string> properties, CancellationToken cancellationToken)
+		{
+			SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken);
+
+			// Validate and extract string.Format information
+			if (!TryExtractStringFormatInfo(node, out InvocationExpressionSyntax invocation, out var formatString, out ArgumentSyntax[] arguments))
+			{
+				return document;
+			}
+
+			// Verify this is actually a string.Format call
+			if (!await IsStringFormatInvocation(document, invocation, cancellationToken))
+			{
+				return document;
+			}
+
+			// Find the parent interpolated string and apply the transformation
+			return await ApplyInterpolatedStringTransformation(document, root, node, formatString, arguments);
+		}
+
+		private bool TryExtractStringFormatInfo(InterpolationSyntax node, out InvocationExpressionSyntax invocation, out string formatString, out ArgumentSyntax[] arguments)
+		{
+			invocation = null;
+			formatString = null;
+			arguments = null;
+
+			// Get the string.Format invocation from the interpolation
+			if (node.Expression is not InvocationExpressionSyntax inv)
+			{
+				return false;
+			}
+
+			invocation = inv;
+
+			// Extract format string and arguments
+			if (invocation.ArgumentList.Arguments.Count < 1)
+			{
+				return false;
+			}
+
+			ArgumentSyntax formatArgument = invocation.ArgumentList.Arguments[0];
+			if (formatArgument.Expression is not LiteralExpressionSyntax formatLiteral ||
+				!formatLiteral.Token.IsKind(SyntaxKind.StringLiteralToken))
+			{
+				return false;
+			}
+
+			formatString = formatLiteral.Token.ValueText;
+			arguments = invocation.ArgumentList.Arguments.Skip(1).ToArray();
+			return true;
+		}
+
+		private async Task<bool> IsStringFormatInvocation(Document document, InvocationExpressionSyntax invocation, CancellationToken cancellationToken)
+		{
+			SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken);
+			SymbolInfo symbolInfo = semanticModel.GetSymbolInfo(invocation, cancellationToken);
+			return symbolInfo.Symbol is IMethodSymbol methodSymbol &&
+				   methodSymbol.Name == "Format" &&
+				   methodSymbol.ContainingType?.SpecialType == SpecialType.System_String;
+		}
+
+		private Task<Document> ApplyInterpolatedStringTransformation(Document document, SyntaxNode root, InterpolationSyntax node, string formatString, ArgumentSyntax[] arguments)
+		{
+			// Find the parent interpolated string
+			InterpolatedStringExpressionSyntax interpolatedString = node.FirstAncestorOrSelf<InterpolatedStringExpressionSyntax>();
+			if (interpolatedString == null)
+			{
+				return Task.FromResult(document);
+			}
+
+			// Convert the string.Format to interpolated content
+			List<InterpolatedStringContentSyntax> newContents = ConvertStringFormatToInterpolatedContents(formatString, arguments);
+			if (newContents.Count == 0)
+			{
+				return Task.FromResult(document);
+			}
+
+			// Replace the interpolation node with the new contents in the parent interpolated string
+			var currentContents = interpolatedString.Contents.ToList();
+			var index = currentContents.IndexOf(node);
+			if (index == -1)
+			{
+				return Task.FromResult(document);
+			}
+
+			// Remove the current interpolation and insert the new contents
+			currentContents.RemoveAt(index);
+			currentContents.InsertRange(index, newContents);
+
+			// Create new interpolated string with the updated contents
+			InterpolatedStringExpressionSyntax newInterpolatedString = interpolatedString.WithContents(SyntaxFactory.List(currentContents));
+
+			// Replace in the syntax tree
+			root = root.ReplaceNode(interpolatedString, newInterpolatedString);
+
+			return Task.FromResult(document.WithSyntaxRoot(root));
+		}
+
+		private List<InterpolatedStringContentSyntax> ConvertStringFormatToInterpolatedContents(string formatString, ArgumentSyntax[] arguments)
+		{
+			var result = new List<InterpolatedStringContentSyntax>();
+			var placeholderPattern = new Regex(@"\{(\d+)(?::([^}]*))?\}",
+				RegexOptions.None, TimeSpan.FromSeconds(1));
+			var lastIndex = 0;
+
+			foreach (Match match in placeholderPattern.Matches(formatString))
+			{
+				// Add text before the placeholder
+				if (match.Index > lastIndex)
+				{
+					var textContent = formatString.Substring(lastIndex, match.Index - lastIndex);
+					if (!string.IsNullOrEmpty(textContent))
+					{
+						SyntaxToken textToken = SyntaxFactory.Token(SyntaxTriviaList.Empty,
+							SyntaxKind.InterpolatedStringTextToken,
+							textContent, textContent, SyntaxTriviaList.Empty);
+						result.Add(SyntaxFactory.InterpolatedStringText(textToken));
+					}
+				}
+
+				// Parse the placeholder
+				if (int.TryParse(match.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var argIndex) && argIndex < arguments.Length)
+				{
+					ExpressionSyntax expression = arguments[argIndex].Expression;
+					InterpolationSyntax interpolation;
+
+					// Add format specifier if present
+					if (match.Groups[2].Success && !string.IsNullOrEmpty(match.Groups[2].Value))
+					{
+						InterpolationFormatClauseSyntax formatClause = SyntaxFactory.InterpolationFormatClause(
+							SyntaxFactory.Token(SyntaxKind.ColonToken),
+							SyntaxFactory.Token(SyntaxTriviaList.Empty, SyntaxKind.InterpolatedStringTextToken,
+								match.Groups[2].Value, match.Groups[2].Value, SyntaxTriviaList.Empty));
+						interpolation = SyntaxFactory.Interpolation(expression, null, formatClause);
+					}
+					else
+					{
+						interpolation = SyntaxFactory.Interpolation(expression);
+					}
+
+					result.Add(interpolation);
+				}
+				else
+				{
+					// Invalid placeholder - return empty collection instead of null for graceful handling
+					return [];
+				}
+
+				lastIndex = match.Index + match.Length;
+			}
+
+			// Add remaining text
+			if (lastIndex < formatString.Length)
+			{
+				var remainingText = formatString.Substring(lastIndex);
+				if (!string.IsNullOrEmpty(remainingText))
+				{
+					SyntaxToken textToken = SyntaxFactory.Token(SyntaxTriviaList.Empty,
+						SyntaxKind.InterpolatedStringTextToken,
+						remainingText, remainingText, SyntaxTriviaList.Empty);
+					result.Add(SyntaxFactory.InterpolatedStringText(textToken));
+				}
+			}
+
+			return result;
+		}
+	}
+}

Philips.CodeAnalysis.MaintainabilityAnalyzers/Maintainability/AvoidToStringOnStringAnalyzer.cs

@@ -56,4 +56,4 @@ public override void Analyze()
 			}
 		}
 	}
-}
+}

Philips.CodeAnalysis.MaintainabilityAnalyzers/Maintainability/AvoidToStringOnStringCodeFixProvider.cs

@@ -39,4 +39,4 @@ protected override async Task<Document> ApplyFix(Document document, InvocationEx
 			return document.WithSyntaxRoot(rootNode);
 		}
 	}
-}
+}

Philips.CodeAnalysis.Test/Maintainability/Maintainability/AvoidStringFormatInInterpolatedStringCodeFixProviderTest.cs

@@ -0,0 +1,97 @@
+// © 2025 Koninklijke Philips N.V. See License.md in the project root for license information.
+
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Philips.CodeAnalysis.Common;
+using Philips.CodeAnalysis.MaintainabilityAnalyzers.Maintainability;
+using Philips.CodeAnalysis.Test.Helpers;
+using Philips.CodeAnalysis.Test.Verifiers;
+
+namespace Philips.CodeAnalysis.Test.Maintainability.Maintainability
+{
+	[TestClass]
+	public class AvoidStringFormatInInterpolatedStringCodeFixProviderTest : CodeFixVerifier
+	{
+		[TestMethod]
+		[TestCategory(TestDefinitions.UnitTests)]
+		public async Task CodeFixSimpleStringFormatTest()
+		{
+			var givenText = @"
+using System;
+
+class Test
+{
+	public void Method()
+	{
+		var firstName = ""John"";
+		var lastName = ""Doe"";
+		var result = $""Hello {string.Format(""{0} {1}"", firstName, lastName)}"";
+	}
+}
+";
+
+			var expectedText = @"
+using System;
+
+class Test
+{
+	public void Method()
+	{
+		var firstName = ""John"";
+		var lastName = ""Doe"";
+		var result = $""Hello {firstName} {lastName}"";
+	}
+}
+";
+
+			await VerifyDiagnostic(givenText, DiagnosticId.AvoidStringFormatInInterpolatedString).ConfigureAwait(false);
+			await VerifyFix(givenText, expectedText).ConfigureAwait(false);
+		}
+
+		[TestMethod]
+		[TestCategory(TestDefinitions.UnitTests)]
+		public async Task CodeFixStringFormatWithFormatSpecifierTest()
+		{
+			var givenText = @"
+using System;
+
+class Test
+{
+	public void Method()
+	{
+		var value = 42;
+		var result = $""Value: {string.Format(""{0:D2}"", value)}"";
+	}
+}
+";
+
+			var expectedText = @"
+using System;
+
+class Test
+{
+	public void Method()
+	{
+		var value = 42;
+		var result = $""Value: {value:D2}"";
+	}
+}
+";
+
+			await VerifyDiagnostic(givenText, DiagnosticId.AvoidStringFormatInInterpolatedString).ConfigureAwait(false);
+			await VerifyFix(givenText, expectedText).ConfigureAwait(false);
+		}
+
+		protected override CodeFixProvider GetCodeFixProvider()
+		{
+			return new AvoidStringFormatInInterpolatedStringCodeFixProvider();
+		}
+
+		protected override DiagnosticAnalyzer GetDiagnosticAnalyzer()
+		{
+			return new AvoidStringFormatInInterpolatedStringAnalyzer();
+		}
+	}
+}