* Add reproducer for #34872

* Fix bug and add test

* WIP

* Test similar scenario in VB

* Add void check in ClassifyConversionFromType, update tuple tests

* Cleanup

Implements a design change where overrides are allowed to change the
type of the member as long as there is an implicit nullable reference
conversion from the overriding type to the overridden type according to
the nullable variance rules.

Fixes #23268
Fixes #30958

Closes #28834.
Closes #30061.

Fixes #29956

Also introduce a helper `TypeSymbol.IsVoidType()`

Track l-values in conditional operator
Assignment to ref variable produces safety warnings

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

The NullableWalker is revised so that the inferred state of an expression is either `NotNull` or `MaybeNull` (represented by the new type `NullableFlowState`).  There is no longer such as thing as an oblivious rvalue.  There are four kinds of lvalues:
- oblivious lvalues read as NotNull but null can be written to them
- annotated lvalues read as MaybeNull and null can be written to them
- unannotated lvalues read as NotNull and null may not be written to them
- unconstrained type parameters read as MaybeNull but null may not be written to them

In order to preserve the safety in the face of such unconstrained type parameters, we warn immediately when a null value of such a type is introduced.  This is a safety warning.  The contexts in which such a warning are given are
- `default` and `default(T)`
- `null` conversion to `T` (when `T` is known to be ref type)
- `e?.M()` when the return type is `T`
- dynamic conversion or cast to `T` when the dynamic might be null
- explicit conversion to `T`
- `e as T` when there is not an implicit conversion from the type of `e` to `T`
- a call to a method like `FirstOrDefault()` that is annotated with `[MaybeNull] (not yet implemented)

We remove the hidden diagnostics previously computed by the NullableWalker.

We add debugger display support for a number of types used by the NullableWalker.  The display for `NullableWalker` summarizes the computed nullability of variables in a nice compact form.

We remove support for definite assignment in the NullableWalker.  Some scenarios involving the use of not-definitely-assigned variables may cause cascaded diagnostics.  We might remove them in the future by initializing all vaiables to the `NotNull` state when they enter scope.

We overhaul and simplify the inplementation of conversions, the null-conditional operator, and result inference for lifted operators.

We simplify the Meet and Join operations so that they form a lattice on both the NullableAnnotation and NullableFlowState.

Catch variables are now initialized to a non-null state on entry to the catch block.

In unreachable code, every expression produces a non-null rvalue.  An erroneous expression produces a non-null rvalue (to suppress cascaded diagnostics).

Remove NonNullTypes context and other unnecessary information stored in TypeSymbolWithAnnotations. (#30913)

Remove NonNullTypes context and other unnecessary information stored in TypeSymbolWithAnnotations.

Fixes #30845.

Explicitly handle nullability analysis for unconstraint type parameters.

Related to #29981, #29993

Handle tuple conversions and extension method `this` argument conversions in NullableWalker (#29679)

There is no conversion between ref like types and either object or generic parameters (even if constrained to struct) in either direction. This change enforces that rule and adds tests around pattern matching, which exercises this rule.

Type inference with nullable reference types

! operator should suppress warnings on array element types and constructed type arguments

* Stack alloc parsed to spans

* PR feedback

* Document the breaking change

Merging on behalf of @alrz. 

Conflicts:
	src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs
	src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionKind.cs
	src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionKindExtensions.cs
	src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs

Conflicts:
	src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
	src/Compilers/CSharp/Portable/Binder/Binder_Query.cs
	src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
	src/Compilers/CSharp/Portable/Errors/ErrorCode.cs