We triaged some of the [championed features](https://github.com/dotnet/csharplang/issues?q=is%3Aopen+is%3Aissue+label%3A%22Proposal+champion%22), to give them a tentative milestone and ensure they had a champion.
As part of this we revisited potential 7.1 features and pushed several out.
1. Implicit interface implementation in Visual Basic *(VB 16)*
2. Delegate and enum constraints *(C# X.X)*
3. Generic attributes *(C# X.0 if even practical)*
4. Replace/original *(C# X.0 if and when relevant)*
5. Bestest betterness *(C# 7.X)*
6. Null-coalescing assignments and awaits *(C# 7.X)*
7. Deconstruction in from and let clauses *(C# 7.X)*
8. Target-typed `new` expressions *(C# 7.X)*
9. Mixing fresh and existing variables in deconstruction *(C# 7.1)*
10. Implementing `==` and `!=` on tuple types *(C# 7.X)*
11. Declarations in embedded statements *(No)*
12. Field targeted attributes on auto-properties *(C# 7.1)*
# Implicit interface implementation in Visual Basic
This long-requested feature in VB would also help deal with problems related to [default implementations of interface members](https://github.com/dotnet/csharplang/issues/52).
## Conclusion
Candidate for VB 16.
# Delegate and enum constraints
[Champion "Generic constraint `delegate` (or allow `System.Delegate` as a constraint)"](https://github.com/dotnet/csharplang/issues/103)
Even though this would work in principle, there are bugs in most versions of the runtime so that it wouldn't work correctly (it was never exercised).
We need a mechanism to understand which target runtime it works on. We need that for many things, and are currently looking at that. Until then, we can't take it.
## Conclusion
Candidate for a major C# version, if we can make a sufficient number of runtime versions deal with it.
# Replace/original
[Champion "Replace/original and code generation extensions"](https://github.com/dotnet/csharplang/issues/107)
If there's renewed investment in source generators, we'll add this, but this is not driven from the language end.
## Conclusion
Candidate for a major C# version, if and when source generators or similar efforts take place.
Links well with target typed `default` expressions, but too much design and potential fallout for 7.1. Interaction with anonymous objects as well.
## Conclusion
Candidate for a minor C# release in the 7.X wave.
# Mixing fresh and existing variables in deconstruction
[Champion "Mix Declarations and Variables in Deconstruction"](https://github.com/dotnet/csharplang/issues/125)
This rounds out the C# 7.0 experience, and was a late design change we didn't get to implementing.
May lead to occasional confusion, as in `M((int x, y) = e)` (declaring `y`)? We are OK with that.
## Conclusion
Candidate for C# 7.1.
# Implementing `==` and `!=` on tuple types
[Champion "Support for == and != on tuple types"](https://github.com/dotnet/csharplang/issues/190)
There's design work. It's not just call `.Equals` recursively.
`==` today works between int and byte, for instance. We should probably make `(i1, i2) == (b1, b2)` work with that same equality.
Also for generics, for a type parameter `T` and a `t` of that type, we should allow `(t, i) == (null, 0)` by recursively applying the special "compare to null" semantics of equality over type parameters of C# today.
Too big for 7.1.
## Conclusion
Candidate for a minor C# release in the 7.X wave.
# Declarations in embedded statements
Now that you can declare expression variables in an embedded statement, it's odd that old-fashioned declaration statements are forbidden in an embedded position (such as an if-branch, for instance). However, now that you can use a discard instead of a dummy variable declaration, the motivating scenario also goes away.