csharplang/meetings/2017/LDM-2017-06-28.md

C# Language Design Notes for Jun 28, 2017

Agenda

1. Tuple name round-tripping between C# 6.0 and C# 7.0
2. Deconstruction without ValueTuple
3. Non-trailing named arguments

Tuple name round-tripping between C# 6.0 and C# 7.0

There are a few unintended breaking changes with tuples that came out through real use cases.

Say there's an interface IUtil:

public interface IUtil
{
    void M((int a, int b) x);
}

I want to implement this interface with code that works both in C# 6.0, but it turns out I can't! In C# 7.0 we force you to use the same tuple element names when you implement an interface member, but of course you can't do that (and aren't being forced to) in C# 6.0, where your only option is to use ValueTuple<...> directly.

Maybe using the TupleName attribute directly in C# 6.0 would help? It is hard to use, but it turns out VS 2015 happily inserts it for you to match the attribute found on the interface member. Little does it know that this attribute is about to become compiler-reserved in C# 7.0, and if you try to compile the C# 6.0 compliant implementation with the attribute in C# 7.0, it still fails, now complaining that you cannot use that attribute in source code!

There are no less than two breaking changes here, so we'll address them one at a time:

Issue 1: C# 6.0 has to implement it without names, but C# 7.0 requires names

This will not do. We need to relax the rules in C# 7.0 to allow for a C# 6.0 implementation to continue compiling.

A couple of reasonable options:

• a tuple type without names can always be given when one with names is required (but one with different names cannot)
• you are permitted to omit required names only if you use the ValueTuple<...> syntax, not with tuple syntax

The latter is attractive in that it pushes things to a corner, but it does break the fact that ValueTuple<int, string> is exactly equivalent to (int, string) in all scenarios.

It also has a bit of a problem in establishing whether the tuple syntax was used:

itf I {
	void M((int a, int b) x);
}

cls Base {
	public void M((int, int) y);
}

// Separate assembly
cls Derived, I {} // how does it know which syntax Base used?

Conclusion

Let's go with a strict version of the former option: If a member has any tuple element names in it, and is required to match another member (by overriding or implementing), then all required tuple element names have to be matched. Only a member declaration with no tuple element names in it can override or implement a member in which tuple element names are found, without matching those names.

Issue 2: VS 2015 Implement Interface will explicitly spit the attributes, but C# 7.0 doesn't allow them

This would have been a problem with dynamic too, but we never really heard of it. Maybe there was less usage, more of a gap between framework version, or the impact was less because we didn't have round tripping back then. For whatever reason, this never seemed to be a problem before.

Options:

• Keep the attribute usage an error
• Allow it but ignore it
  • possibly with a warning when tuple syntax is used

Conclusion

Keep it an error, willing to take it up again if necessary. We are unsure that this is really a problem.

For the future we want to get better at marking attributes as compiler-only in a well-known way, so that they won't be put in source code even by older compilers. One option is to do that using Obsolete; then no compiler will allow them in source, but will be happy to detect or emit them in metadata.

Deconstruction without ValueTuple

Deconstructing assignments are expressions, and their value is a tuple. This is natural from a language perspective, even though the result value of assignments is rarely used, and we expect this goes for deconstructing assignments as well.

Unfortunately, even in the common case where the assignment occurs as an expression statement (so the resulting tuple is discarded), the compiler currently still requires the associated ValueTuple<...> type to be present. That means you have the hassle of importing ValueTuple even when you never use a tuple - if you happen to make use of deconstruction.

Conclusion

We'll rewrite the compiler to be more lazy about ValueTuple<...>, requiring it only when it actually needs it for code gen.

Non-trailing named arguments

It looks like this is making it into C# 7.2. The basic idea is that we allow named arguments that are in their place, positionally to be followed by positional arguments. This is mainly for the self-documenting convenience of calling out the meaning of a positional argument where it is non-obvious in the calling context. However, it can be useful for disambiguation of overloads also.