Fixes #39975

* Implement lambda discard parameters

* Remove duplicate tests

* Factor logic to recognize underscore tokens

* Align symbol display with other discards

* Distinguish discards in QuickInfo

* Add IsDiscard property instead of IDiscardSymbol

* Adjust IDE logic to use IsDiscard

* Avoid large tuple return

* Add test for ref/out discard parameters

* Address PR feedback and test plan ideas

* Allow in expression trees

* Support general discard parameters

* Add IDE tests

* Emit with unspeakable name

* Remove unused error code

* Only support lambdas

* Fix tests

* Address some PR feedback

* Address remaining feedback

* Address more feedback

* Fix conflict

* Update PublicAPI.Unshipped.txt

* Update PublicAPI.Unshipped.txt

* Add ChangeSignature tests

* Add SymbolCompletion tests

* Add InlineRename test

* Typo

This change also separates implementation of ISymbol interfaces from internal symbols in C# compiler.

Fixes #38686

* x == default is valid object equality for reference types
* Block null == default

Fixes #7398
Fixes #37572
Relates to https://github.com/aspnet/Razor/issues/614 and many other customer accommodations that are no longer needed.

History of this bug:  When constant folding a long sequence of string concatenations, there is an intermediate constant value for every left-hand operand.  So the total memory consumed to compute the whole concatenation was *O(n^2)*.  The compiler would simply perform this work and eventually run out of memory, simply crashing with no useful diagnostic.  Later, the concatenation implementation was instrumented so it would detect when it was likely to run out of memory soon, and would instead report a diagnostic at the last step. See https://github.com/dotnet/roslyn/commit/f177077665a5bef862014f1898b961d1759c9248.  Test `Bug529600()` was added to demonstrate that we produced a diagnostic.  However, the compiler still consumed *O(n^2)* memory for the concatenation and this test used to consume so much memory that it would cause other tests running in parallel to fail because they might not have enough memory to succeed.  So the test was disabled and eventually removed.  The compiler would still crash with programs containing large string concatenations, or consume huge amounts of memory and take a long time before reporting a diagnostic, so the underlying problem had not been addressed.

Here we have revised the implementation of constant folding string concatenations so that it requires *O(n)* memory and remove the old instrumentation.  As a consequence the test `Bug529600()` now runs very quickly and does not consume gobs of memory.

Implements https://github.com/dotnet/csharplang/issues/2389
Fixes #35958

Note that the switch expression conversion is not a standard implicit conversion.  Specifically, it should not be considered as a valid implicit conversion as input to a user-defined conversion, as that could permit two chained user-defined conversions.

Also changes binding of switch expression to ECMA so it can interact properly with switch expressions.
Fixes #14965

Fixes #37111

Move to a different lowering from for nullable value types to work around a bug in TransformCompoundAssignmentLHS. Addressed PR feedback.

Update ??= to convert the result type of the expression to the underlying value type when targetting a nullable value type.

Fixes #29956

Also introduce a helper `TypeSymbol.IsVoidType()`

A reference to an unconstrained type parameter in nullable-disabled code should be treated as *oblivious*, and therefore reading them should be considered to produce non-null values, and we are permitted to assign null values to them without a diagnostic.
Fixes #34842

Also disable the old WRN_DotOnDefault when the nullable feature is enabled.
Fixes #34855

* Implement pattern-matching in the nullable walker

Fixes #29909
Fixes #31881
Fixes #30952
Fixes #33499
Fixes #30597
Fixes #32414
Fixes #23944

* Remove infinite recursion by using an empty struct cache.

* Changes per code review comments.

* Remove debugging code accidentally left behind.

* Analysis of patterns-matching in the nullable walker requires valid (>0) slots.

* Skip a flaky test

* Patch after merge.

* Make ctor private to force use of factory methods

* Correct a typo.

* Fixup after merge.

 Adjust base access with explicit base according to latest LDM decisions

- Restrict accessed members to immediate members of the specified type.
- Change accessibility of explicit implementations in interfaces to ‘protected’.

e.g. `ReturnType`, `ElementType`, etc.

- Rename `TypeSymbolWithAnnotations` to `TypeWithAnnotations`
- Rename its type field from `TypeSymbol` to `Type`
- Fields of Symbols that are of type `TypeWithAnnotations` that are currently named `Type` would be renamed `TypeWithAnnotations`
Fixes #33736

* Eliminate unspeakable NullableAnnotation values.
* Dynamic invocations result in an oblivious state
Fixes #33638
* Fix up expected diagnostics
Due to #33924
* Rename NullableAnnotation.Unknown to NullableAnnotation.Oblivious

* Add initial support for specifying explicit base type in the base access.

Relevant LDM notes https://github.com/dotnet/csharplang/blob/master/meetings/2018/LDM-2018-11-14.md .

* PR feedback

- Fix parsing regression of expressions involving parens when used as a case expression or a constant pattern.
Fixes #33054
Fixes #33208
- Incidentally also correct and test the precedence of the switch expression
See https://github.com/dotnet/csharplang/blob/master/proposals/patterns.md#switch-expression for the spec.
- Fix terminology to match the spec - "conditional expression" rather than "ternary expression".

Fixes #32290 
Fixes #32169 
Fixes #32141 
Fixes #32025 

Use Binder CheckFeatureAvailability for simplicity. Set hasErrors based on feature checks as needed.

Don't warn about "!", regardless of context (https://github.com/dotnet/csharplang/blob/master/meetings/2018/LDM-2018-10-29.md).

Closes #30177.
Closes #30021.

Moved C# to not pass multiple children to constructors, and instead just pass the original bound node.