This unifies our API naming convention. When standard is in the name
then we are using the netstandard2.0 API set and when it is not then it
is the simple desktop mscorlib46.

Both variants are necessary for CompileAndVerify style functions because
many of our tests that use it can only run on desktop or simply need to
have some of the netstandard2.0 API set missing.

* Permit selecting an instance from a type in a sub-expression in nameof(...)

Fixes #20600

* Ensure modreq must exist on PE symbols that C# compiler expects them to have

* PR feedback

* More tests + feedback

* Skip tests on mono due to bug

* Added Assert.True(IsOverride) for overrides

* Improve error tolerance when parsing invalid implicit arrays.

Provide helper for common pattern.

Update test.

* Be resilient to infinite loops.

Fixes:#24348

* Fix `is` and pattern-matching behavior in presence of implicit UD conversion
and also an explicit reference conversion. User-defined conversions should
never be considered for `is` and pattern-matching.
Fixes #24522

CheckPresenceOfTypeIdentifierAttribute - avoid requesting syntax trees if we know that we already decoded all well-known attributes. (#24576)

Fixes https://devdiv.visualstudio.com/DevDiv/_workitems?id=537870.

The GetImplicitImplementationDiagnosticLocation method was added in TypeSymbol class in order to find the correct diagnostic location for implicit implementation related errors. Some tests were updated.

This changes the reference assemblies we use for the CoreClr compiler
compilation to be Net Standard 2.0 RTM. Previously they were a beta
version.

This did mean a number of tests had to be moved to be desktop specific
again. This is primarily due to the presence of ValueTuple as a default
type in Net Standard 2.0. Tests that relied on ValueTuple not being
defined had to be moved to net461 which doesn't have that type defined
by default.

Fixes:#24306

The last await-containing expression in an argument triggers spilling of all argument before it.
The value of the expression itself, however, should not be spilled. (there are no awaits after it)

Agreesive spilling may result in substandard codegenration and/or unexpected errors.

The LDM has decided that the following rules should be in effect when
calculating definite assignment for local functions:

  1. The entry point to a local function is always reachable.
  2. Variables captured in local functions are definitely assigned if
  they are definitely assigned in all branches into the local function.

It turns out these rules were almost exactly what the compiler already
implemented, but there was a bug in captured variable detection that
meant that variables captured in lambdas within local functions were
sometimes not counted as captured. This change fixes the bug around
capturing, which should cause the compiler to conform to this
specification.

Fixes #17829

Explicitly marking an argument as an `in` argument has effect on overload resolution and needs to be known to the dynamic binder to be able to make appropriate decisions. For the time being there is not way to pass this additional information.
That would require a small expansion of APIs used by `dynamic`. When we have such API, we should predicate this scenario on the presence of such API.

For now, In order to not perpetuate accidental and likely incorrect behavior we should block this scenario.

Fixes:#22813

* Make sure 'in' is honored in cref parsers/completion lists

* Clean up

* PR Comments

* Document API breaking change

This looks like simple oversight. The binder being used for type
parameters was retrieved from the binder factory since we didn't
explicitly pass one. For members this is correct since the binder
factory can be queried for top-level binders. This is not correct for
local functions because they use method body binders, which are not
accessible from the binder factory.

Mostly, this doesn't matter. The exception is when you try to
speculatively bind an attribute on a type parameter. Here, you need an
in-method binder and VS will crash if it's the wrong binder. This was
uncommon since attributes on type parameters are not permitted in local
functions, but VS should not crash.

Fixes #17814