Update analyzer to detect string.Format instead of string.Join in interpolated strings

Co-authored-by: bcollamore <57269455+bcollamore@users.noreply.github.com>

Author: Copilot

Documentation/Diagnostics/PH2145.md

@@ -1,25 +1,22 @@
-# PH2145: Avoid string.Join in interpolated string
+# PH2145: Avoid string.Format in interpolated string
 
 | Property | Value  |
 |--|--|
 | Package | [Philips.CodeAnalysis.MaintainabilityAnalyzers](https://www.nuget.org/packages/Philips.CodeAnalysis.MaintainabilityAnalyzers) |
 | Diagnostic ID | PH2145 |
 | Category  | [Maintainability](../Maintainability.md) |
-| Analyzer | [AvoidStringJoinInInterpolatedStringAnalyzer](https://github.com/philips-software/roslyn-analyzers/blob/main/Philips.CodeAnalysis.MaintainabilityAnalyzers/Maintainability/AvoidStringJoinInInterpolatedStringAnalyzer.cs)
+| Analyzer | [AvoidStringFormatInInterpolatedStringAnalyzer](https://github.com/philips-software/roslyn-analyzers/blob/main/Philips.CodeAnalysis.MaintainabilityAnalyzers/Maintainability/AvoidStringFormatInInterpolatedStringAnalyzer.cs)
 | CodeFix  | No |
 | Severity | Info |
 | Enabled By Default | No |
 
 ## Introduction
 
-Using `string.Join` within interpolated strings can sometimes be simplified and made more readable by using alternative approaches.
+Using `string.Format` within interpolated strings is redundant and can be simplified by using direct interpolation.
 
 ## How to solve
 
-Consider simplifying the string construction by using alternative methods such as:
-- Direct interpolation with collection elements
-- LINQ methods for string building
-- Traditional string concatenation if appropriate
+Replace `string.Format` calls inside interpolated strings with direct interpolation of the variables.
 
 ## Example
 
@@ -29,26 +26,30 @@ class BadExample
 {
     public void BadMethod()
     {
-        var items = new[] { "apple", "banana", "cherry" };
-        var result = $"Items: {string.Join(", ", items)}";
+        var firstName = "John";
+        var lastName = "Doe";
+        var result = $"Hello {string.Format("{0} {1}", firstName, lastName)}";
 
-        var reasons = new[] { "Error 1", "Error 2" };
-        var message = $@"Command failed. Reasons:{string.Join(Environment.NewLine, reasons)}";
+        var name = "John";
+        var age = 30;
+        var message = $"User info: {string.Format("Name: {0}, Age: {1}", name, age)}";
     }
 }
 ```
 
-And potential replacement approaches:
+And the simplified replacement:
 ``` cs
 class GoodExample
 {
     public void GoodMethod()
     {
-        var items = new[] { "apple", "banana", "cherry" };
-        var result = "Items: " + string.Join(", ", items); // Move out of interpolation
+        var firstName = "John";
+        var lastName = "Doe";
+        var result = $"Hello {firstName} {lastName}";
 
-        var reasons = new[] { "Error 1", "Error 2" };
-        var message = "Command failed. Reasons:" + Environment.NewLine + string.Join(Environment.NewLine, reasons);
+        var name = "John";
+        var age = 30;
+        var message = $"User info: Name: {name}, Age: {age}";
     }
 }
 ```

Philips.CodeAnalysis.Common/DiagnosticId.cs

@@ -137,6 +137,6 @@ public enum DiagnosticId
 		AvoidEmptyRegions = 2141,
 		AvoidCastToString = 2142,
 		AvoidAssemblyGetEntryAssembly = 2143,
-		AvoidStringJoinInInterpolatedString = 2145,
+		AvoidStringFormatInInterpolatedString = 2145,
 	}
 }

Philips.CodeAnalysis.MaintainabilityAnalyzers/Maintainability/AvoidStringFormatInInterpolatedStringAnalyzer.cs

@@ -0,0 +1,54 @@
+// © 2024 Koninklijke Philips N.V. See License.md in the project root for license information.
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Philips.CodeAnalysis.Common;
+
+namespace Philips.CodeAnalysis.MaintainabilityAnalyzers.Maintainability
+{
+	[DiagnosticAnalyzer(LanguageNames.CSharp)]
+	public class AvoidStringFormatInInterpolatedStringAnalyzer : SingleDiagnosticAnalyzer<InterpolatedStringExpressionSyntax, AvoidStringFormatInInterpolatedStringSyntaxNodeAction>
+	{
+		private const string Title = @"Avoid string.Format in interpolated string";
+		private const string MessageFormat = @"Consider simplifying string.Format usage in interpolated string";
+		private const string Description = @"Using string.Format within interpolated strings can be simplified by using direct interpolation";
+
+		public AvoidStringFormatInInterpolatedStringAnalyzer()
+			: base(DiagnosticId.AvoidStringFormatInInterpolatedString, Title, MessageFormat, Description, Categories.Maintainability, isEnabled: false)
+		{ }
+	}
+
+	public class AvoidStringFormatInInterpolatedStringSyntaxNodeAction : SyntaxNodeAction<InterpolatedStringExpressionSyntax>
+	{
+		public override void Analyze()
+		{
+			// Look for interpolated string expressions
+			foreach (InterpolatedStringContentSyntax content in Node.Contents)
+			{
+				if (content is InterpolationSyntax interpolation && ContainsStringFormatCall(interpolation.Expression))
+				{
+					Location location = interpolation.GetLocation();
+					ReportDiagnostic(location);
+				}
+			}
+		}
+
+		private bool ContainsStringFormatCall(ExpressionSyntax expression)
+		{
+			// Check if this is a direct string.Format call
+			if (expression is InvocationExpressionSyntax invocation)
+			{
+				// Use semantic analysis to properly identify string.Format
+				SymbolInfo symbolInfo = Context.SemanticModel.GetSymbolInfo(invocation);
+				if (symbolInfo.Symbol is IMethodSymbol methodSymbol)
+				{
+					return methodSymbol.Name == "Format" &&
+						   methodSymbol.ContainingType?.SpecialType == SpecialType.System_String;
+				}
+			}
+
+			return false;
+		}
+	}
+}

Philips.CodeAnalysis.MaintainabilityAnalyzers/Maintainability/AvoidStringJoinInInterpolatedStringAnalyzer.cs

@@ -10,27 +10,27 @@
 namespace Philips.CodeAnalysis.Test.Maintainability.Maintainability
 {
 	[TestClass]
-	public class AvoidStringJoinInInterpolatedStringAnalyzerTest : DiagnosticVerifier
+	public class AvoidStringFormatInInterpolatedStringAnalyzerTest : DiagnosticVerifier
 	{
 		protected override DiagnosticAnalyzer GetDiagnosticAnalyzer()
 		{
-			return new AvoidStringJoinInInterpolatedStringAnalyzer();
+			return new AvoidStringFormatInInterpolatedStringAnalyzer();
 		}
 
 		[TestMethod]
 		[TestCategory(TestDefinitions.UnitTests)]
-		public async Task StringJoinInInterpolatedStringTriggersWarning()
+		public async Task StringFormatInInterpolatedStringTriggersWarning()
 		{
 			var code = @"
 using System;
-using System.Collections.Generic;
 
 class Test
 {
 	public void Method()
 	{
-		var items = new List<string> { ""a"", ""b"", ""c"" };
-		var result = $""Items: {string.Join("", "", items)}"";
+		var firstName = ""John"";
+		var lastName = ""Doe"";
+		var result = $""Hello {string.Format(""{0} {1}"", firstName, lastName)}"";
 	}
 }
 ";
@@ -39,20 +39,18 @@ public void Method()
 
 		[TestMethod]
 		[TestCategory(TestDefinitions.UnitTests)]
-		public async Task StringJoinWithEnvironmentNewLineTriggersWarning()
+		public async Task StringFormatWithMultipleArgumentsTriggersWarning()
 		{
 			var code = @"
 using System;
-using System.Collections.Generic;
 
 class Test
 {
-	public string CommandType { get; set; }
-	public List<string> ReasonList { get; set; }
-	
-	public string Method()
+	public void Method()
 	{
-		return $@""{CommandType}  Reasons:{string.Join(Environment.NewLine, ReasonList)}"";
+		var name = ""John"";
+		var age = 30;
+		var result = $""User info: {string.Format(""Name: {0}, Age: {1}"", name, age)}"";
 	}
 }
 ";
@@ -61,18 +59,38 @@ public string Method()
 
 		[TestMethod]
 		[TestCategory(TestDefinitions.UnitTests)]
-		public async Task InterpolatedStringWithoutStringJoinIsOk()
+		public async Task InterpolatedStringWithoutStringFormatIsOk()
+		{
+			var code = @"
+using System;
+
+class Test
+{
+	public void Method()
+	{
+		var firstName = ""John"";
+		var lastName = ""Doe"";
+		var result = $""Hello {firstName} {lastName}"";
+	}
+}
+";
+			await VerifySuccessfulCompilation(code).ConfigureAwait(false);
+		}
+
+		[TestMethod]
+		[TestCategory(TestDefinitions.UnitTests)]
+		public async Task StringFormatOutsideInterpolatedStringIsOk()
 		{
 			var code = @"
 using System;
-using System.Collections.Generic;
 
 class Test
 {
 	public void Method()
 	{
-		var items = new List<string> { ""a"", ""b"", ""c"" };
-		var result = $""Items: {items.Count}"";
+		var firstName = ""John"";
+		var lastName = ""Doe"";
+		var result = string.Format(""Hello {0} {1}"", firstName, lastName);
 	}
 }
 ";