A newer version of Microsoft.CodeAnalysis.* causes some of the rules to fire in more cases.  Fixing them proactively before we ingest newer versions of these libs.

Fixes issue (#71808) where deeply nested structures caused the start set
computation to overflow the stack.
Re-introduces bottom-up computation of start sets that (#71234) had reworked.
As an optimization, the Singleton node's set field is reused as the start set
field, since for Singleton nodes the two concepts coincide and other node types
do not need the set.

* Add missing APIs to contract customization

* Address feedback

Missed passing `ID()` for a test case.

Native varargs is not supported on win-arm32: #12979

* Simplify "st[s]fld" spilling

* Add a test

* [mono] Update MonoAOTCompiler to provide reference assemblies location

* Address feedback

* Make ReferenceAssembliesForPGO an ITaskItem[]

* Default ReferenceAssembliesForPGO

* Clean up

[main] Update dependencies from dotnet/xharness dotnet/runtime-assets dotnet/emsdk dotnet/msquic (#71762)

[main] Update dependencies from dotnet/xharness dotnet/runtime-assets dotnet/emsdk dotnet/msquic

* Tar: for directories, use a default mask that has the 'x' bit.

Without the 'x'-bit, the directories that get created are not
accessible.

* Apply suggestions from code review
Co-authored-by: NStephen Toub <stoub@microsoft.com>

* Update src/libraries/System.Formats.Tar/tests/TarTestsBase.cs
Co-authored-by: NStephen Toub <stoub@microsoft.com>
Co-authored-by: NStephen Toub <stoub@microsoft.com>

* Dont create HashSet unless needed in IsTypeSerializable

* Apply suggestions from code review

* Tar, Zip: respect umask when creating files.

* Update UnixExtractFilePermissionsCompat

* Replace const int with const UnixFileMode.

* Also run tests with zero umask

* Use file-scoped types in RegexGenerator output

* Update System.Text.RegularExpressions.Tests.csproj

* Delete the unused GTF_ICON_FIELD_OFF

* Do not try to find "IND(struct ARR_ADDR)" handle

Leftover from GT_INDEX.

* Delete the zero-offset field sequence map

For statics at a zero offset, preserve the "CNS_INT 0" node instead.

* Make all field sequences singletons

* Print struct field offsets in the sequence

* Improve address mode marking to handle COMMAs

This avoids regressing cases where we now have new CSE
opportunities for statics with static init helper calls.

* Delete NotAField

Replace with using "nullptr" directly.

Note that "nullptr" can mean both an absense of a field
sequence and an "implicit" sequence of struct fields.

* Refactor the field sequence store

Now that we don't need the map to be a set, we can apply some optimizations.

* FieldSeqNode -> FieldSeq

* Turn asserts into "noway_assert"s

We don't expect empty sequences: they are either coming from
the "IsFieldAddr" code path, which disallows these, or from
the boxed static code path, where we should always have them.

* Fix formatting

* Take down SPMI

* Resurrect SPMI to work around a CG2 bug

[wasm][debugger] Enable onCallFrame evaluation of static fields in classes/interfaces from a static method. (#70560)

* Test for DIM - expected behavior.

* Static tests: renaming variables and small refactoring.

* Added new testcases and merged existing tests into Theories.

* Fix for resolving the name with namespace prefix matching the current frame location.

* Fix for tests failing on InvokeMethod in runtime.

* Applied smallest suggestions of @radical's review.

* Reverted deleting and renaming tests - only adding new.

* Corrected the logic + added new tests.

* Removed unnecessary logging.

Convert them to GenTreeVisitor.

We may see this in stress modes, and in general the JIT should be able to handle the flag.

System.Linq.Parallel has multiple generic cycles in it. We probably hit them all in the System.Linq.Parallel.Tests assembly. We would be compiling the test forever (or until running out of memory) because we didn't detect one of them.

Add detection for the case where the recursion is entered through a generic interface virtual method call. The compiler terminates the infinite expansion after the user-specifiable cutoff point.

The test shows the pattern and the expected behavior.

There was an optimization that was trying to prevent the compiler from doing unnecessary work when analyzing generic virtual methods. The optimization is invalid.

- Find shape data for stateful collection marshallers
- Add marshalling strategy implementations for stateful collection marshalling of blittable elements and non-blittable elements
- Refactor non-blittable element handling into a base class for shared functionality between stateless and stateful
  - Probably can share more for blittable element handling too, but I'll plan to do that in a follow-up after getting general support in.
- Tests for stateful marshallers for `List<T>` and arrays 

* Concurrency fixes and refactoring for clarity

Removed builder reference from SymbolicRegexNode instances; builder now
has to be passed in. Since the builder is not thread safe this clarifies
the locking required in the matcher when using it.
Moved matching specific state from the builder to the matcher. This
includes state and transition arrays.
Simplify character kind code by eliminating duplication of logic.

* Changes from review and cleanup

DfaMatchingState is now just MatchingState

* Comment on NFA mode IDs

Fixes #61482

* Remove implicit fallback to reflection-based serialization. Fix #71714

Include JsonSerializerContext in JsonSerializerOptions copy constructor. Fix #71716

Move reflection-based converter resolution out of JsonSerializerOptions. Fix #68878

* Address feedback & add one more test

* Update src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializerContext.cs
Co-authored-by: NStephen Toub <stoub@microsoft.com>

* fix build

* Bring back throwing behavior in JsonSerializerContext and add tests

* Only create caching contexts if a resolver is populated

* Add null test for JsonSerializerContext interface implementation.

* skip RemoteExecutor test in netfx targets

* Add DefaultJsonTypeInfoResolver test for types with JsonConverterAttribute

* remove nullability annotation

* Update src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializerOptions.Converters.cs
Co-authored-by: NKrzysztof Wicher <mordotymoja@gmail.com>
Co-authored-by: NStephen Toub <stoub@microsoft.com>
Co-authored-by: NKrzysztof Wicher <mordotymoja@gmail.com>

This adds some richer debug information in the form of inline trees and
IL<->native mappings with inlinee information, plus an ETW event in the private
runtime provider to report it back. A COMPlus variable is used to opt-in to
generating and storing this larger debug information.

On the JIT side, we now store a few more fields of data for each inline context
in release builds:

* Its ordinal which is required to be incrementally assigned

* The actual IL offset of the IL instruction leading to the creation of the
  inline context

* The method handle of the inlinee

On the EE side we store the new debug information together with the normal debug
info, reusing the flag byte used for patchpoint information.

The hope is that the new richer format of debug info can eventually replace the
old one, but this won't happen in .NET 7 as I expect it will take some time to
come up with the right format for this data and the right set of fields to
expose. In the meantime this environment variable and event/debugging APIs are
mainly to be used as an opt-in way to start incrementally prototyping on the
tooling side without needing special checked builds of the runtime/JIT.

* Obsolete Create(string) cryptographic factory methods

* Add to list of diagnostics

* Fix EventSource deadlock

Initializing NativeRuntimeEventSource inside the EventListener static constructor
could lead to a deadlock where a 2nd thread holding the ETW lock calls back
though ETWCallback and tries to get EventListener lock which blocks on the
static constructor.

Fixes #70870

* ReturnsSocketFlags test

* fix

* ReceiveTruncated_TruncatedFlagIsSetOnReceive

* Fix some null reference exceptions and improve nullable annotations.

* Remove new line that was introduced

While experimenting with doing less spilling in #70932 I have realized
that the change I made in #68736 was not correct. There I commented that
"we now only check interference with the stack entries that are not
arguments since we now know that arguments will be normalized and kept
in order" -- this is not correct since the normalization may spill args
to new statements. It is possible that a later argument that we are
normalizing interferes with an earlier argument that was not normalized.
In that case the logic could reorder these two arguments by spilling
only the later argument to a new statement.

This changes the logic back to be more similar to what it was before --
we iterate the arguments in reverse order, popping them from the top as
we go along with normalization now checking interference with previous
args as well. Since we cannot walk args backwards we also need an extra
loop (as before) to walk the signature information in order.