Discussion: Permit tuple element names in deconstruction only if they match with source (same as patterns)

[alrz]

It is useful for self-documenting code and also to make sure we're capturing the right elements

// both compile fine but only one is correct
var (count, sum) = e;
var (sum, count) = e;

// if the developer wants to be explicit 
(sum: int sum, count: int count) = e;

// or just spell out names for discards
(int sum, count: _) = e;

// or use a different name for variables
(sum: int s, count: int c) = e;

If we're deconstructing with Deconstruct, names must match with parameter names.

Note: Patterns already behave as above for both tuples and Deconstruct.

class C {
  void Deconstruct(out int i, out int j) => throw null;
  void M() {
    switch (this) {
      case (i:1,j:2): // ok
        break;
      case (x:3,y:4): // error
        break;
    }
  }
  void M((int i, int j) t) {
    switch (t) {
      case (i:1,j:2): // ok
        break;
      case (x:3,y:4): // error
        break;
    }
  }
}

[yaakov-h]

This would be a breaking change, and would also require code like this to be significantly more verbose:

class Foo
{
    void M(Player player, Target target)
    {
        var (playerX, playerY) = player.GetPoint();
        var (targetX, targetY) = target.GetPoint();
        // ...
    }
}

Perhaps it would be simpler for an Analyzer to warn on deconstructions that we can see are likely to be incorrect (e.g. swapped variable names)?

[alrz]

This would be a breaking change

Currently any use of names in deconstruction produces an error (CS8187). The suggestion is to relax that and only error on mismatched names, just like what we have for patterns.

[yaakov-h]

Oh, I think I understand now.

So this would still be valid syntax (but a program error):

var (count, sum) = e;
var (sum, count) = e;

But this new syntax would be valid:

(count: int count, sum: int sum) = (count: 3, sum: 9);

And this new syntax would be invalid:

(sum: int sum, count: int count) = (count: 3, sum: 9);

?