* Clean up string resources, use Arcade resx generator

* CodeLens resources


* Use NET20 instead of NETFX20

* Refactor tuple implementation

* Tweaks

* Address PR feedback

* Pass tuple data in constructors

* Address more feedback

* Tweak comparison

* Restore constructWithTypeParameters flag to avoid overflow

* Assert that tuple parameter matches TupleUnderlyingType somewhat

* Rename to TupleData. Address some IDE feedback

* Remaining TODO2's

* Fix last IDE test!

* Factor array comparison

* Tweak WithTupleData and EqualsIgnoringTupleUnderlyingType

* Expand a test

* Remove duplicate line

* Remove an EE test for badly formed ValueTuple type

* PR feedback from Neal

* Restore an IDE test without ValueTuple

* Rename constants

* Restore formatting

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

Fixes #24737

When we added support for tracking static fields as part of nullable
analysis, we used -1 for their containing slot. Negative numbers are
not meant to be used as actual slots and flowed through the flow analysis
code, they are only used as sentinels from slot-returning methods to indicate
that the variable in question is not tracked. The appropriate root
slot for a static variable is the same as the root slot for a top-level tracked
variable (like a local), which is 0.

Fixes #38725

* Require /unsafe flag for SkipLocalsInitAttribute

* Use Unsafe

Some violations were us approximating theories, so this just converts
to using theories.

Including more projects that have a dependency on ilasm.

* EE: Do not trim comments from expression preceding a quote

* Top-level types enumeration refactoring

* Simplify DefinitionMap

* Include namespaces in synthesized definition map

* Add SynthesizedNamespaceSymbol

* Embedded Attributes

* Test synthesized attributes

* Clean up EnC tests

* Clean up symbol matcher tests

* Ref readonly return type, in parameter symbol matching tests

* Enable using ref readonly returns, in parameters, ref structs during debugging

* More tests

* ReadOnly struct members

* Fix langauge version mismatch

* Merge fix ups

* Feedback, skip tests

* Remove RoslynProjectType

* Remove ToolsVersion, namespace from Project tags

* Remove updating of MSBuildAllProjects

* Update BuildBoss

* Delete DeployTooolsetCompiler

This changes the order of evaluation for string concatenation to follow
the C# specification.

Previously, when the compiler lowered a string concatenation containing
any objects which were not strings (or implicitly convertible to
strings), it would generate a call to an appropriate overload of
`string.Concat` taking `objects`. This meant that all expressions being
concatenated were evaluated, then `string.Concat` called, which called
`.ToString()` on all of them.

E.g.

    "x" + y + z

got compiled to :

    string.Concat("x", y, z)

Here, `y` and `z` are evaluated to `object` (boxing them if necessary),
and then they have `.ToString()` called on them by `string.Concat`.

This is technically against the C# specification, which defines string
concatenation as a sequence of left-associative calls to one of:

    string operator +(string x, string y);
    string operator +(string x, object y);
    string operator +(object x, string y);

So the above expression should conceptually be compiled to:

    op_Addition(op_Addition("x", y), z)

That is, `y` is evaluated to `object` and concatenated with `"x"`
before `z` is evaluated to `object`.

The decision was made to change this behaviour in #522.

This change brings a very important advantage: we can now fully evaluate
`y` to a string before we evaluate `z`, which means we're allowed to
compile the above to:

    string.Concat("x", y.ToString(), z.ToString())

This means that:

 - We don't box `y` and `z` if they're value types
 - We don't call `ToString()` on `"x"` (which is harmless but pointless)

This commit implements this change.

Calls are no longer emitted to overloads of `string.Concat` which take
`object` - instead, all parameters are evaluated to a string, and then
an appropriate overload of `string.Concat` which takes `strings` is
called.

Care is taken to deal with different types of expressions in different
ways:

 - Strings or types which are implicitly convertible to string never have
   .ToString called on them
 - Reference types (and unconstrained generics) have ?.ToString() called
   on them
 - A copy is made of non-readonly non-constant value types (and
   unconstrained generics), before.ToString() is called on the copy. This
   is to preserve the previous behaviour where value types were boxed, and
   so any side-effects of ToString() weren't reflected in the original.
 - A copy isn't made of readonly value types, as we know that ToString()
   can't have side-effects.

We emit `call` to special struct types, as we know these have their own
ToString implementation which won't be removed. For other value types,
we emit a constrained virtual call. This follows the precedent set in

For unary concatenation (e.g. `thing + ""`) we now emit
`thing?.ToString() ?? ""` instead of `string.Concat(thing) ?? ""`.

This does increase the size of generated code. My impression is that the
unit tests which were affected by this changed increased in size by
about 10%. This is somewhat offset by the fact that we can now call

    string.Concat(string, string, string, string)

instead of

    string.Concat(object[])

(since there is no overload of string.Concat which takes 4 objects),
which reduces the size of some methods significantly.

Fixes #522

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

Reflects the changes described in https://github.com/dotnet/csharplang/pull/2214.

Range now looks optimistically for some special members with optional
parameters, but will fall back to the Range constructor if they aren't
present.

This change also removes all of the specialized codegen that was going
on with arrays and strings in favor of expected helpers or real members.

This change does two things: shrinks the required Index/Range APIs to
a minimal set, and changes the new required API names to those decided
in the latest CoreFX design review 
(CoreCLR change at https://github.com/dotnet/coreclr/pull/22331).

Debugger EE 'Internal error' if DebuggerBrowsable when 'newslot' C# property overrides field (#26049)

closes #30767

closes #30755

closes #30754

closes #30034

closes #30033

closes #30031

They were previously on C# 7.0 due to our reliance on new types. That
went away when we moved to the new pragma based design.

closes #30030