This change is now just a test-only change that verifies the current behavior.

Fixes #22581

Ensure the invariant that “each syntax node has at most one corresponding explicit IOperation node” is met for all test scenarios we have at the moment. (#22894)

Related to #22229.

The following changes are made:
- Mark some synthesized bound nodes as compiler generated.
- Use correct syntax for a tuple on the left hand side of deconstruction.
- For throw statements, no longer add IExpressionStatementOperation on top of IThrowOperation node.
- For IInterpolatedStringText node, ensure the underlying ILiteralExpression is marked as implicit because it is sharing syntax node with its parent.

Refactor ISingle and IMulti to IVariableDeclarator and IVariableDeclaration, to match syntax terms and be less confusing.

This matches the VB behavior and avoids GetOperation returning null for parenthesized expression.
Fixes #22751

Address more feedback from design meeting and expose IOperation.IsExpression and IOperation.IsStatement properties

1. Rename `ILocalInitializer` to `IVariableInitializer`
2. Refactor OperationFactory methods
3. Change type of `IVariableDeclaration.Initializer` from `IOperation` to `IVariableInitializer`

Fixes #22429

* Adding cobyrc file for testing

* Adding isImplicit info to ioperation tests

* Adding Language name to the test dumper

* Formatting change to test dumper

* Removing cobyrc file

* Fixing more tests

* Resolving conflicts

* Moving the language to assert check

* Resolving conflicts

* Reacting to merge conflict

Fixes #22265

Fixes https://github.com/dotnet/roslyn/issues/21748

1. Add IsChecked flag for IIncrementExpression and ICompoundAssignmentExpression
2. Add back VB specific binary operator kinds
3. Add more unit tests and fix baselines of existing tests

* Rename Foo to Goo

* Rename ifoo to igoo

* Add back BOMs

LocalFunctionTypeParameterSymbol isn't necessary as long as the functionality around type constraints can be moved into a shared base class between ordinary method symbols and local function symbols.
In fact, it would be very useful to have a shared base symbol aside from MethodSymbol between local functions, lambdas, and other source method symbols. To this end, I've renamed SourceMemberMethodSymbol to SourceOrdinaryMethodSymbol (since it is just used for ordinary member-level methods), SourceMethodSymbol to SourceMemberMethodSymbol (since it is only used as a base class for member-level method-like functions like ordinary methods, constructors, property accessors, et al.), and added a new abstract class SourceMethodSymbol that is the root of both LocalFunctionSymbol and SourceMemberMethodSymbol. This lets us unify all source method-like symbols under a single base class, SourceMethodSymbol.
The first three commits perform the refactoring, while the last commit actually removes LocalFunctionTypeParameterSymbol and moves the necessary functionality into SourceMethodSymbol. I expect more functionality to be moved over in subsequent PRs.

Fixes #17244

* Fixes crash in `is` operator used with tuples
Fixes #19310

* Matching an expression of type `byte?` with a pattern of type `int` should not be allowed
* Add documentation for the breaking change matching `int?` against the pattern `long x`
Fixes #19151

* Unify subsumption implementations
Fixes #19273

* Greatly improved code gen for value type pattern match
Fixes #16129
Fixes #18944
Fixes #14252

* Add test confirming that #19122 is fixed.
Fixes #19122

* make sure that binary or operators aren't the same in different contexts

* use ToTestDisplayString

Add support for an OperationTreeVerifier - test only OperationWalker to dump operation tree. (#11918)

The dump approach should enable to us to (relatively) easily extend the existing C# and VB binding tests to verify the operation tree.
I have moved the existing IOperation tests to the dump approach and also added couple of additional tests to demonstrate how to write these tests for entire method body operation tree verification.