InterpolatedStringHandler and Indexers

[nietras]

I am trying to define an API that supports using InterpolatedStringHandler on set_Item for an indexer. This works but similar to how you can forward the instance of the type which a method belongs to by using InterpolatedStringHandlerArgument I'd like to do that for the indexer too. That is define the set_Item like set_Item2 as shown below, and then have C# support that. For now I don't know how to actually apply InterpolatedStringHandlerArgument to value to get it to call TraceInterpolatedStringHandler(int literalLength, int formattedCount, Row row). How can I bend things to get this working?

PS: One option would be to use a ThreadLocal variable 😱

using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Text;

public class C
{
    public void C_Test()
    {
        M(new Row(), 42);
    }

    public void M(Row row, int value)
    {
        row["C"] = $"Test {value}";
        row.set_Item2("C", $"Test {value}");
    }
}

public class Row
{
    readonly Dictionary<string, string> _nameToValue = new();
    internal readonly StringBuilder _stringBuilder = new();

    public TraceInterpolatedStringHandler this[string index]
    {
        set { _nameToValue[index] = value.GetFormattedText(); }
    }

    [SpecialName]
    public void set_Item2(string index, [InterpolatedStringHandlerArgument("")] ref TraceInterpolatedStringHandler value)
    {
        _nameToValue[index] = value.GetFormattedText();
    }
}

[InterpolatedStringHandler]
public ref struct TraceInterpolatedStringHandler
{
    // Storage for the built-up string
    readonly StringBuilder builder;

    public TraceInterpolatedStringHandler(int literalLength, int formattedCount)
    {
        builder = new StringBuilder(literalLength);
        Trace.WriteLine($"\tliteral length: {literalLength}, formattedCount: {formattedCount}");
    }

    public TraceInterpolatedStringHandler(int literalLength, int formattedCount, Row row)
    {
        row._stringBuilder.Clear();
        builder = row._stringBuilder;
        Trace.WriteLine($"\tliteral length: {literalLength}, formattedCount: {formattedCount} REUSE");
    }

    public void AppendLiteral(string s)
    {
        Trace.WriteLine($"\tAppendLiteral called: {{{s}}}");

        builder.Append(s);
        Trace.WriteLine($"\tAppended the literal string");
    }

    public void AppendFormatted<T>(T t)
    {
        Trace.WriteLine($"\tAppendFormatted called: {{{t}}} is of type {typeof(T)}");

        builder.Append(t?.ToString());
        Trace.WriteLine($"\tAppended the formatted object");
    }

    internal string GetFormattedText() => builder.ToString();
}

sharplab.io

If you run C_Test this outputs something like:

	literal length: 5, formattedCount: 1
	AppendLiteral called: {Test }
	Appended the literal string
	AppendFormatted called: {42} is of type System.Int32
	Appended the formatted object
	literal length: 5, formattedCount: 1 REUSE
	AppendLiteral called: {Test }
	Appended the literal string
	AppendFormatted called: {42} is of type System.Int32
	Appended the formatted object

[nietras]

@ltrzesniewski reminded me that you can of course apply the attribute to the setter parameter by:

    public TraceInterpolatedStringHandler this[string index]
    {
        [param: InterpolatedStringHandlerArgument("")]
        set { _nameToValue[index] = value.GetFormattedText(); }
    }

However, the compiler does not use this and still uses TraceInterpolatedStringHandler(int literalLength, int formattedCount).

This might be more of a C# language issue so should perhaps raise that there instead.

[ltrzesniewski]

I think you should open a Roslyn issue:

• Either interpolated string handler support on indexers was never intended and is a side effect of the current implementation
• Or indexers should be treated exactly like a call to the set_Item method, in which case [param: InterpolatedStringHandlerArgument("")] should be supported

In either case, this needs a clarification, as right now we have partial support. I suppose this applies to property setters too.