Relax restrictions on tuple operations for ref structs

[RenderMichael]

The following code will not work:

Span<byte> v0 = ...;
Span<byte> v1 = ...;

// swap
(v0, v1) = (v1, v0); // CS0306: The type `Span<byte>` may not be used as a type argument

Because it tries to fit the tuple into a ValueTuple<,>. However, many tuple "operations" are inlined, such as the above when using an array.

This can be worked around with a manual swap:

Span<byte> v0 = ...;
Span<byte> v1 = ...;
scoped Span<byte> vtemp = ...;

// swap
vtemp = v0;
v0 = v1;
v1 = vtemp;

The only difference between the Span<byte> and the lowered byte[] versions is the addition of the scoped keyword, which hopefully isn't an issue.

Concerns

To what extent is the whole "you're not actually using a ValueTuple under the hood" an implementation detail? If my suggestion is followed up on, it would no longer be one.

[huoyaoyuan]

Such expression also depends on the existence of ValueTuple type. It fails to compile on older versions of .NET Framework.

[RenderMichael]

So even if ValueTuple is not actually used, it's still formally a dependency?

In that case, this suggestion would be about relaxing that dependency, and having tuple "operations" such as the swap in my example be some kind of pseudo-tuple or phantom-tuple.

[HaloFour]

Right, per the language spec technically you are using ValueTuple there, the compiler just knows that it can elide it safely without that being observable (or at least shouldn't be observable), so it does. I think you'd have to formalize cases in the spec as to where the language can use tuples without actually using tuples.