feat: Add analyzer to prefer interpolated strings over string.Format with comprehensive edge case handling (disabled by default)

Documentation/Diagnostics/PH2148.md

@@ -0,0 +1,70 @@
+# PH2148: Prefer interpolated strings over string.Format
+
+| Property | Value  |
+|--|--|
+| Package | [Philips.CodeAnalysis.MaintainabilityAnalyzers](https://www.nuget.org/packages/Philips.CodeAnalysis.MaintainabilityAnalyzers) |
+| Diagnostic ID | PH2148 |
+| Category  | [Readability](../Readability.md) |
+| Analyzer | [PreferInterpolatedStringAnalyzer](https://github.com/philips-software/roslyn-analyzers/blob/main/Philips.CodeAnalysis.MaintainabilityAnalyzers/Readability/PreferInterpolatedStringAnalyzer.cs)
+| CodeFix  | No |
+| Severity | Error |
+| Enabled By Default | No |
+
+## Introduction
+
+Prefer interpolated strings over `string.Format` calls with simple placeholders for better readability and reduced error-proneness.
+
+## How to solve
+
+Replace `string.Format` calls that use simple placeholders like `{0}`, `{1}`, etc. with interpolated strings.
+
+## Example
+
+Code that triggers a diagnostic:
+``` cs
+class BadExample
+{
+    public void BadMethod()
+    {
+        int num = 42;
+        string name = "World";
+
+        // Case 1: Interpolated string preferred
+        string str1 = string.Format("Hello {0}, this is number {1}", name, num);
+
+        // Case 2: Unnecessary string.Format call
+        string str2 = string.Format("Simple string with no placeholders");
+    }
+}
+
+```
+
+And the replacement code:
+``` cs
+class GoodExample
+{
+    public void GoodMethod()
+    {
+        int num = 42;
+        string name = "World";
+
+        // Case 1: Use interpolated string
+        string str1 = $"Hello {name}, this is number {num}";
+
+        // Case 2: Use simple string literal
+        string str2 = "Simple string with no placeholders";
+    }
+}
+
+```
+
+## What it ignores
+
+The analyzer is conservative and only suggests conversion in safe cases:
+
+- **Format specifiers**: `string.Format("Value: {0:N2}", value)` - requires more complex conversion logic
+- **Non-literal format strings**: `string.Format(formatVariable, args)` - can't analyze statically
+
+## Configuration
+
+This analyzer does not offer any special configuration. The general ways of [suppressing](https://learn.microsoft.com/en-us/dotnet/fundamentals/code-analysis/suppress-warnings) diagnostics apply.

Philips.CodeAnalysis.AnalyzerPerformance/Program.cs

@@ -1,6 +1,5 @@
 // © 2023 Koninklijke Philips N.V. See License.md in the project root for license information.
 
-using Microsoft.Build.Logging.StructuredLogger;
 using Philips.CodeAnalysis.Common;
 
 namespace Philips.CodeAnalysis.AnalyzerPerformance
@@ -36,7 +35,7 @@
 			}
 		}
 
 		private static void AnalyzePackages(NamedNode namedNode)
 		{
 			foreach (BaseNode analyzerPackageNode in namedNode.Children)
 			{
@@ -76,13 +75,13 @@
 			}
 		}
 
 		private static void AnalyzerItems(Folder namedAnalyzerPackageFolder)
 		{
 			foreach (BaseNode analyzerMessage in namedAnalyzerPackageFolder.Children)
 			{
 				if (analyzerMessage is Item item)
 				{
-					var record = AnalyzerPerformanceRecord.TryParse(item.Title);
+					AnalyzerPerformanceRecord record = AnalyzerPerformanceRecord.TryParse(item.Title);
 					Records.Add(record);
 				}
 			}

Philips.CodeAnalysis.Benchmark/Program.cs

@@ -4,11 +4,6 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using BenchmarkDotNet.Attributes;
-using BenchmarkDotNet.Running;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Philips.CodeAnalysis.DuplicateCodeAnalyzer;
 
 namespace Philips.CodeAnalysis.Benchmark
@@ -24,7 +19,7 @@
 	public class InputDataSet
 	{
 		public string Folder { get; set; }
 		public IReadOnlyDictionary<MethodDeclarationSyntax, IEnumerable<SyntaxToken>> Data { get; set; }
 
 		public override string ToString()
 		{
@@ -32,7 +27,7 @@
 		}
 	}
 
 	[SimpleJob(launchCount: LaunchCount, warmupCount: WarmupCount, targetCount: TargetCount)]
 	public class DuplicationDetectorBenchmark
 	{
 		public const int LaunchCount = 3;
@@ -43,7 +38,7 @@
 		private const int BaseModulus2 = 227;
 		private const int Modulus2 = 1000005;
 
 		[ParamsSource(nameof(ValuesForA))]
 		public InputDataSet A { get; set; }
 
 		// public property
@@ -97,14 +92,14 @@
 			});
 		}
 
 		[Benchmark]
 		public void OriginalHashParameters()
 		{
 			DuplicateDetector library = new();
 			TestDictionary(library, BaseModulus1, Modulus1);
 		}
 
 		[Benchmark]
 		public void BiggerPrimes()
 		{
 			DuplicateDetector library = new();

Philips.CodeAnalysis.Common/DiagnosticId.cs

@@ -139,6 +139,7 @@ public enum DiagnosticId
 		AvoidStringFormatInInterpolatedString = 2145,
 		AvoidToStringOnString = 2146,
 		AvoidVariableNamedUnderscore = 2147,
+		PreferInterpolatedString = 2148,
 		AvoidProblematicUsingPatterns = 2149,
 		AvoidTodoComments = 2151,
 		AvoidUnusedToString = 2153,

Philips.CodeAnalysis.DuplicateCodeAnalyzer/AvoidDuplicateCodeFixProvider.cs

@@ -111,23 +111,22 @@
 		public override async Task<CodeAction> GetFixAsync(FixAllContext fixAllContext)
 		{
 			var diagnosticsToFix = new List<KeyValuePair<Project, ImmutableArray<Diagnostic>>>();
-			var titleFormat = "Add all duplications in {0} {1} to the exceptions list";
 			string title = null;
 			switch (fixAllContext.Scope)
 			{
 				case FixAllScope.Document:
 					{
 						ImmutableArray<Diagnostic> diagnostics = await fixAllContext.GetDocumentDiagnosticsAsync(fixAllContext.Document).ConfigureAwait(false);
 						diagnosticsToFix.Add(new KeyValuePair<Project, ImmutableArray<Diagnostic>>(fixAllContext.Project, diagnostics));
-						title = string.Format(titleFormat, "document", fixAllContext.Document.Name);
+						title = $"Add all duplications in document {fixAllContext.Document.Name} to the exceptions list";
 						break;
 					}
 				case FixAllScope.Project:
 					{
 						Project project = fixAllContext.Project;
 						ImmutableArray<Diagnostic> diagnostics = await fixAllContext.GetAllDiagnosticsAsync(project).ConfigureAwait(false);
 						diagnosticsToFix.Add(new KeyValuePair<Project, ImmutableArray<Diagnostic>>(fixAllContext.Project, diagnostics));
-						title = string.Format(titleFormat, "project", fixAllContext.Project.Name);
+						title = $"Add all duplications in project {fixAllContext.Project.Name} to the exceptions list";
 						break;
 					}
 				case FixAllScope.Solution:
@@ -197,7 +196,7 @@
 				}
 
 				StringBuilder appending = new();
 				foreach (var methodName in newMethodNames)
 				{
 					_ = appending.Append(methodName);
 					_ = appending.Append(Environment.NewLine);

Philips.CodeAnalysis.MaintainabilityAnalyzers/Maintainability/AlignOperatorsCountAnalyzer.cs

@@ -15,10 +15,6 @@ namespace Philips.CodeAnalysis.MaintainabilityAnalyzers.Maintainability
 	[DiagnosticAnalyzer(LanguageNames.CSharp)]
 	public class AlignOperatorsCountAnalyzer : DiagnosticAnalyzerBase
 	{
-		private const string Title = "Align number of {0} and {1} operators.";
-		private const string MessageFormat = Title;
-		private const string DescriptionFormat =
-			"Overload the {1} operator, when you overload the {0} operator, as they are often used in combination with each other.";
 		private const string Category = Categories.Maintainability;
 		private const string Plus = "+";
 
@@ -47,12 +43,12 @@ private static DiagnosticDescriptor GenerateRule(string first, string second, Di
 		{
 			return new(
 				diagnosticId.ToId(),
-				string.Format(Title, first, second),
-				string.Format(MessageFormat, first, second),
+				$"Align number of {first} and {second} operators.",
+				$"Align number of {first} and {second} operators.",
 				Category,
 				DiagnosticSeverity.Error,
 				isEnabledByDefault: false,
-				description: string.Format(DescriptionFormat, first, second)
+				description: $"Overload the {second} operator, when you overload the {first} operator, as they are often used in combination with each other."
 			);
 		}
 

Philips.CodeAnalysis.MaintainabilityAnalyzers/Naming/NamespacePrefixAnalyzer.cs

@@ -18,8 +18,6 @@ public class NamespacePrefixAnalyzer : DiagnosticAnalyzerBase
 
 
 		private const string TitleForEmptyPrefix = @"Specify the namespace prefix in the .editorconfig file";
-		private const string MessageFormatForEmptyPrefix = @"Please specify the namespace prefix in the .editorconfig file Eg. dotnet_code_quality.{0}.namespace_prefix = [OrganizationName].[ProductName]";
-		private const string DescriptionForEmptyPrefix = MessageFormatForEmptyPrefix;
 		private const string Category = Categories.Naming;
 
 		private void Analyze(SyntaxNodeAnalysisContext context)
@@ -49,7 +47,7 @@ private void Analyze(SyntaxNodeAnalysisContext context)
 		public static readonly string RuleId = DiagnosticId.NamespacePrefix.ToId();
 
 		public static readonly DiagnosticDescriptor RuleForIncorrectNamespace = new(RuleId, TitleForIncorrectPrefix, MessageFormatForIncorrectPrefix, Category, DiagnosticSeverity.Error, isEnabledByDefault: true, description: DescriptionForIncorrectPrefix);
-		public static readonly DiagnosticDescriptor RuleForEmptyPrefix = new(RuleId, TitleForEmptyPrefix, string.Format(MessageFormatForEmptyPrefix, RuleId), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, description: string.Format(DescriptionForEmptyPrefix, RuleId));
+		public static readonly DiagnosticDescriptor RuleForEmptyPrefix = new(RuleId, TitleForEmptyPrefix, $"Please specify the namespace prefix in the .editorconfig file Eg. dotnet_code_quality.{RuleId}.namespace_prefix = [OrganizationName].[ProductName]", Category, DiagnosticSeverity.Error, isEnabledByDefault: true, description: $"Please specify the namespace prefix in the .editorconfig file Eg. dotnet_code_quality.{RuleId}.namespace_prefix = [OrganizationName].[ProductName]");
 
 
 		public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get { return ImmutableArray.Create(RuleForIncorrectNamespace, RuleForEmptyPrefix); } }

Philips.CodeAnalysis.MaintainabilityAnalyzers/Readability/PreferInterpolatedStringAnalyzer.cs

@@ -0,0 +1,210 @@
+// © 2019 Koninklijke Philips N.V. See License.md in the project root for license information.
+
+using System;
+using System.Collections.Immutable;
+using System.Globalization;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+using Philips.CodeAnalysis.Common;
+
+namespace Philips.CodeAnalysis.MaintainabilityAnalyzers.Readability
+{
+	[DiagnosticAnalyzer(LanguageNames.CSharp)]
+	public class PreferInterpolatedStringAnalyzer : DiagnosticAnalyzerBase
+	{
+		[Flags]
+		private enum ConversionResult
+		{
+			None = 0,
+			CanConvert = 1,
+			IsUnnecessary = 2
+		}
+		private const string Title = @"Prefer interpolated strings over string.Format";
+		private const string MessageFormat = @"Replace string.Format with interpolated string for better readability";
+		private const string Description = @"Interpolated strings are more readable and less error prone than string.Format";
+
+		private const string UnnecessaryTitle = @"Unnecessary call to string.Format";
+		private const string UnnecessaryMessageFormat = @"Remove unnecessary call to string.Format";
+		private const string UnnecessaryDescription = @"string.Format calls with no placeholders are unnecessary";
+
+		private const string Category = Categories.Readability;
+
+		private static readonly DiagnosticDescriptor Rule = new(
+			DiagnosticId.PreferInterpolatedString.ToId(),
+			Title,
+			MessageFormat,
+			Category,
+			DiagnosticSeverity.Error,
+			isEnabledByDefault: false,
+			description: Description);
+
+		private static readonly DiagnosticDescriptor UnnecessaryRule = new(
+			DiagnosticId.PreferInterpolatedString.ToId(),
+			UnnecessaryTitle,
+			UnnecessaryMessageFormat,
+			Category,
+			DiagnosticSeverity.Error,
+			isEnabledByDefault: false,
+			description: UnnecessaryDescription);
+
+		public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule, UnnecessaryRule);
+
+		protected override void InitializeCompilation(CompilationStartAnalysisContext context)
+		{
+			context.RegisterOperationAction(OnInvocation, OperationKind.Invocation);
+		}
+
+		private void OnInvocation(OperationAnalysisContext operationContext)
+		{
+			var invocation = (IInvocationOperation)operationContext.Operation;
+
+			if (!IsStringFormatMethod(invocation.TargetMethod))
+			{
+				return;
+			}
+
+			ConversionResult result = CanConvertToInterpolatedString(invocation);
+			if (result == ConversionResult.None)
+			{
+				return;
+			}
+
+			Location location = invocation.Syntax.GetLocation();
+			if (result.HasFlag(ConversionResult.IsUnnecessary))
+			{
+				operationContext.ReportDiagnostic(Diagnostic.Create(UnnecessaryRule, location));
+			}
+			else
+			{
+				operationContext.ReportDiagnostic(Diagnostic.Create(Rule, location));
+			}
+		}
+
+		private bool IsStringFormatMethod(IMethodSymbol targetMethod)
+		{
+			return targetMethod.Name == "Format" &&
+				   targetMethod.ContainingType != null &&
+				   targetMethod.ContainingType.SpecialType == SpecialType.System_String;
+		}
+
+		private ConversionResult CanConvertToInterpolatedString(IInvocationOperation invocation)
+		{
+			if (invocation.Arguments.Length < 1)
+			{
+				return ConversionResult.None;
+			}
+
+			// Check if this is an IFormatProvider overload (first parameter is IFormatProvider)
+			if (invocation.TargetMethod.Parameters.Length > 0 &&
+				invocation.TargetMethod.Parameters[0].Type?.Name == "IFormatProvider")
+			{
+				return ConversionResult.None;
+			}
+
+			IOperation formatStringArgument = invocation.Arguments[0].Value;
+
+			// Check if format string is an interpolated string
+			if (formatStringArgument.Kind == OperationKind.InterpolatedString)
+			{
+				return ConversionResult.None;
+			}
+
+			if (formatStringArgument.Kind != OperationKind.Literal ||
+				formatStringArgument.Type?.SpecialType != SpecialType.System_String)
+			{
+				return ConversionResult.None;
+			}
+
+			var formatString = (string)formatStringArgument.ConstantValue.Value;
+
+			// Parse the format string to find actual placeholders, ignoring escaped braces
+			var placeholderCount = CountFormatPlaceholders(formatString);
+
+			if (placeholderCount == 0)
+			{
+				// Only flag as unnecessary if there are no braces at all
+				// If there are escaped braces, string.Format is needed to produce literal braces
+				var hasAnyBraces = formatString.Contains("{") || formatString.Contains("}");
+				if (!hasAnyBraces)
+				{
+					return ConversionResult.CanConvert | ConversionResult.IsUnnecessary;
+				}
+
+				// Has escaped braces but no placeholders - don't suggest conversion
+				return ConversionResult.None;
+			}
+
+			return invocation.Arguments.Length > 1 ? ConversionResult.CanConvert : ConversionResult.None;
+		}
+
+		private int CountFormatPlaceholders(string formatString)
+		{
+			var placeholderCount = 0;
+			var i = 0;
+
+			while (i < formatString.Length)
+			{
+				if (formatString[i] == '{')
+				{
+					if (i + 1 < formatString.Length && formatString[i + 1] == '{')
+					{
+						// Escaped brace {{, skip both characters
+						i += 2;
+						continue;
+					}
+
+					// Look for closing brace
+					var j = i + 1;
+					while (j < formatString.Length && formatString[j] != '}')
+					{
+						j++;
+					}
+
+					if (j < formatString.Length && formatString[j] == '}')
+					{
+						// Found valid placeholder, check if it's a simple numeric placeholder
+						var content = formatString.Substring(i + 1, j - i - 1);
+
+						// Handle alignment options like {0,3} or {0,3:N2} by splitting on ','
+						if (content.Contains(","))
+						{
+							// Has alignment component - bail out as interpolated strings don't support this syntax directly
+							return 0;
+						}
+
+						// Handle format specifiers like {0:N2} by splitting on ':'
+						var colonIndex = content.IndexOf(':');
+						var indexPart = colonIndex >= 0 ? content.Substring(0, colonIndex) : content;
+
+						if (int.TryParse(indexPart.Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out _))
+						{
+							placeholderCount++;
+						}
+						i = j + 1;
+					}
+					else
+					{
+						i++;
+					}
+				}
+				else if (formatString[i] == '}')
+				{
+					if (i + 1 < formatString.Length && formatString[i + 1] == '}')
+					{
+						// Escaped brace }}, skip both characters
+						i += 2;
+						continue;
+					}
+					i++;
+				}
+				else
+				{
+					i++;
+				}
+			}
+
+			return placeholderCount;
+		}
+	}
+}