MA0011 should not be reported when format is culture-invariant

[drieseng]

Version of the Meziantou.Analyzer NuGet package

2.0.243

Rule Identifier

MA0011

Target Framework

.NET 9.0

C# Language version

4.14.0-3.25412.6 (c167adef)

Description

MA0011 is currently reported when there's a method for which there's an overload taking a interpolated string and an overload taking both and IFormatProvider and an interpolated string, and that method is invoked with a fully culture-invariant interpolated string.

Reproduction Steps

Minimal code:

using System;
using System.Runtime.CompilerServices;

using Meziantou.Analyzer.Annotations;

internal sealed class Program
{
    private static void Main(string[] args)
    {
        Print($"{DateTime.Now:D}"); // MA0011 is reported. This is fine as the "D" format is culture-sensitive
        Print($"{new Bar():D}"); // MA0011 is reported. This is fine as the "D" format is culture-sensitive
        Print($"{new Bar():o} | {new Bar():D}"); // MA0011 is reported. This is fine as the "D" format is culture-sensitive

        Print($"{DateTime.Now:o}"); // MA0011 should not be reported as the "o" format is culture invariant
        Print($"{new Bar():o}"); // MA0011 should not be reported as the "o" format is culture invariant
        Print($"XXX"); // MA0011 should not be reported because ... :p
    }

    public static void Print(ref DefaultInterpolatedStringHandler interpolatedStringHandler)
    {
    }

    public static void Print(IFormatProvider provider, ref DefaultInterpolatedStringHandler interpolatedStringHandler)
    {
    }
}

[CultureInsensitiveType(format: "o")]
public sealed class Bar : IFormattable
{
    public string ToString(string? format, IFormatProvider? formatProvider)
    {
        return string.Empty;
    }
}

Other information

No response

[drieseng]

It's getting really late here, so I'm surely missing something.

PS. I'm trying to get my employer to show you some gratitude, but it's apparently not that easy. I'm not yet giving up though.

[meziantou]

That's a good suggestion. I'll need to figure out the right way to handle it with all the cases that may exist with string interpolations. I'll let copilot generate some unit tests. That may help to shape the solution.

[drieseng]

It should probably also work for custom interpolated string handler, but that may again add an extra runtime cost.

[meziantou]

The rule may be like,

• Analyze method invocation
• If it has an argument of type IFormatProvider => do not report
• If there is no overload with a IFormatProvider parameter => do not report
• If a parameter is of type FormattableString or a type decorated with [InterpolatedStringHandler], and the argument is a not culture sensitive interpolated string => do not report
• Otherwise, report

Examples:

var value = DateTime.UtcNow;

// There is no overload available => ok
Sample1($"{value}"); // ok
Sample1($"{value:o}"); // ok

void Sample1(ref DefaultInterpolatedStringHandler handler) => throw null;

// Overload with DefaultInterpolatedStringHandler, a type decorated with InterpolatedStringHandler
Sample2($"{value}"); // non-compliant
Sample2(CultureInfo.InvariantCulture, $"{value}"); // ok
Sample2($"{value:o}"); // ok

void Sample2(ref DefaultInterpolatedStringHandler handler) => throw null;
void Sample2(IFormatProvider format, ref DefaultInterpolatedStringHandler handler) => throw null;

// Overload with FormattableString
Sample3($"{value}"); // non-compliant
Sample3(CultureInfo.InvariantCulture, $"{value}"); // ok
Sample3($"{value:o}"); // ok

void Sample3(FormattableString value) => throw null;
void Sample3(IFormatProvider format, FormattableString value) => throw null;