Allow type pattern matching to have multiple expression bind to the same variable

[lostmsu]

Excerpt from own Roslyn-based code:

switch(...) {
...
case var _ when defaultValue is LambdaExpressionSyntax lambda:
case var _ when defaultValue is ParenthesizedExpressionSyntax parenthesized
        && (lambda = parenthesized.Expression as LambdaExpressionSyntax) != null:
  ...
  break;
}

Should be able to do:

switch(...) {
...
case var _ when defaultValue is LambdaExpressionSyntax lambda:
case var _ when defaultValue is ParenthesizedExpressionSyntax parenthesized
         && parenthesized.Expression is LambdaExpressionSyntax lambda:
  ...
  break;
}

Basically, in expr is Type variable why can't variable be any existing variable of a matching type (e.g. assignable from Type). I'd even be ok with expr is Type out variable, as long as I don't have to do the (... = ... as ...) != null

[alrz]

Relates to #118, #1350

[lostmsu]

Now I realize this should not be limited to switch statements. It should be possible to do it in any expression/statement.
E.g. success = other is XXX xxx || other is YYY yyy && yyy.Val is XXX xxx;

[HaloFour]

Now I realize this should not be limited to switch statements.

That's where the or pattern potentially comes into play.

[lostmsu]

That's where the or pattern potentially comes into play.

Why is there a need for a new syntax? The above example is just a simple logical expression.

[HaloFour]

@lostmsu

Because the use of || with patterns already means something else. This is discussed in more detail in the issues that @alrz posted.

[lostmsu]

@HaloFour my understanding is that or in above is a special syntax to replace case 1: case 2: with case 1 or 2:, and does not have anything to do with type testing pattern matching.

[HaloFour]

@lostmsu

and does not have anything to do with type testing pattern matching.

Those "type tests" are just a very limited form of pattern, just like those constant patterns. C# 8.0 will greatly expand on the types of supported patterns, including recursive patterns, and or will be a way to combine patterns. Rewriting your example with recursive property patterns and or patterns might look like this:

success = other is XXX xxx or YYY { Val: XXX xxx };

Assuming that or patterns allow you to declare the same variable on both sides as long as they're compatible.

[HaloFour]

That said, if you're looking for support for this outside of pattern matching, such as with case guards or Boolean expressions, that would be its own proposal.

[YairHalberstadt]

Closing as championed in #4018