Calling interpolated string handler method on ref parameter (or ref local) causes compilation error

[addabis]

A regression that breaks an existing code that uses StringBuilder.

Version Used:
.NET 6.0 RC1 (Roslyn 4.0)

Steps to Reproduce:

Our codebase uses StringBuilder, but it is reproducible with any [InterpolatedStringHandler].

Use the following:

using System.Runtime.CompilerServices;

namespace Test;

class Program
{
    static void Main()
    {
        Test test = new Test();
        Foo("test", ref test);
    }

    static void Foo(string name, /* CAUSE! */ ref Test state)
    {
        state.Append($"{name}");
    }
}

class Test
{
    public void Append([InterpolatedStringHandlerArgument("")] ref MyInterpolatedStringHandler handler)
    {
    }
}

[InterpolatedStringHandler]
struct MyInterpolatedStringHandler
{
    public MyInterpolatedStringHandler(int literalLength, int formattedCount, Test stringBuilder)
    {
    }

    public void AppendFormatted<T>(T value)
    {
        Console.WriteLine("Hit");
    }
}

Expected Behavior:

Should compile and execute the AppendFormatted method, which is the behavior when ref is removed from the state parameter.

Actual Behavior:

Compilation error:

error CS1615: Argument 3 may not be passed with the 'ref' keyword

(this means argument 3 of the MyInterpolatedStringHandler ctor, i.e. the instance of Test, )

The same happens if the method is invoked on a ref local.

[svick]

Hi Daniel,

this looks like a duplicate of #56579.

[addabis]

Hi Daniel,

this looks like a duplicate of #56579.

Thanks, it seems like that.

I think there is a slight difference though - in case of out parameters you cannot use the overload with [InterpolatedStringHandler] (at least not for value types).

In case of ref, if there is an appropriate ctor on the [InterpolatedStringHandler] (in above example it would be (int, int, ref Test)) the overload can still be used.

[333fred]

This is unrelated to #56579. This is intended behavior: if you're passing Test by ref, you need to accept it by ref in your handler constructor. Generally, it all needs to match up: it's likely you're introducing a bug if you haven't made it line up.

[addabis]

@333fred I'm not sure you've taken into account the whole description. The above code is just an example, I'm having problems with StringBuilder on an existing codebase.

public void Visit<TValue>( string name, TValue value, ref StringBuilder state )
{
    // The following line results in build error.
    state.Append( $"{typeof( TValue )} {name} = {value}; " );
}

If this is intended behavior, the problem is in AppendInterpolatedStringHandler in BCL, which does not have an appropriate overload.

[333fred]

@stephentoub we may want to add a ref overload for Append to deal with this. The other option would be to revisit the rules around ref, but I'm concerned that in cases where you have a struct, not having these strict rules will result in unintended bugs.

[stephentoub]

we may want to add a ref overload for Append to deal with this

Can you elaborate? What overload are you proposing?

[333fred]

An overload to the AppendInterpolatedStringHandler constructor that takes the StringBuilder by ref instead of by value, to deal with the case where a user calls Append on a StringBuilder that was passed by ref instead of by value.

[stephentoub]

An overload to the AppendInterpolatedStringHandler constructor that takes the StringBuilder by ref instead of by value, to deal with the case where a user calls Append on a StringBuilder that was passed by ref instead of by value.

What happens then in the repro when the line:

static void Foo(string name, /* CAUSE! */ ref Test state)

is changed to be:

static void Foo(string name, /* CAUSE! */ in Test state)

? Doesn't the same issue arise? And we can't add both ref and in overloads.