Right now there are two code paths for signing using a keyfile:

1) Full & delay signing implemented using a strong-name provider, which
   calls into the CLR when necessary to do signing.
2) Public signing, which extracts the key directly from the file and
   embeds it manually into the assembly using only portable code.

The tricky part is that (1) also implements a bunch of legacy semantics
on how to resolve the key file from various search paths, since the key
file can also be specified via an attribute.

This behavior is already deprecated, so rather than implement the
complicated file resolution for public sign as well, this PR changes the
command line compilers to always produce an absolute path for the key
file before passing it to CompilationOptions. CreateCompilation now also
has a check to enforce that CryptoKeyFile is an absolute path when
PublicSign is set.

Fixes #8360.

This reverts commit 57a34148.

This reverts commit 760e1204.

This reverts commit e2fc5135.

This reverts commit e3c1ea08.

This still only runs the tests on desktop (for now), but it makes
it possible to run them on coreclr.

Synchronize all corefx references to -23504 and bring in the
xunit coreclr test runner.

Fixes #8287.

This change does the following:

- Deletes the constructor WorkItem(int) leaving only WorkItem(int, string).
- Fixes up many occurences where the URL of the bug was missing / incorrect.
- Removes several WorkItem attributes that had invalid bug ids

Corrects a couple of items noted in #7677

Closes #6233

The Equals method was using reference equality to compare ITypeReference instances.  Correct comparison of that type must use .Equals as equivalent generic values can be different objects.

This surfaced as a bug in determinism.  In the case we had an alias'd using where the target type was generic this Equals method came into play.  Based on whether we got a generic cache hit or not ended up changing the PDB output and as an effect the determinism id of the resulting assembly.

closes #7015

Sometimes called "fake sign" or "OSS sign" public signing is including
the public key in an output assembly and setting the "signed" flag, but
not actually signing the assembly with a private key. This is useful for
open source projects where people want to build assemblies which are
compatible with the released "fully signed" assemblies, but don't have
access to the private key used to sign the assemblies. Since almost no
consumers actually need to check if the assembly is fully signed, these
publicly built assemblies are useable in almost every scenario that the
fully signed one would be used in.

This PR implements support only for C# -- VB will be added soon. If
being used at the command line, the /publicsign flag can be passed to
csc and the /keyfile flag can specify the public key. Unlike fully
signing, a full key pair encoded in the SNK file format is not currently
supported. When using /publicsign, just the public key must be in the
/keyfile file.

When using the API, the public key can be passed directly using the
CryptoPublicKey CompilationOption.

See https://github.com/sarif-standard/sarif-spec

* Change structure from:
   {
      "version": <version>,
      "toolInfo": <toolInfo>,
      "issues": [ <issue>* ]
   }

to:
    {
      "version": <version>,
      "runLogs": [
        {
          "toolInfo": <toolInfo>,
          "issues": [ <issue>* ]
        }
      ]
    }

* Flatten custom properties to conform to requirement for all issue
property values to be strings:

   "customProperties": { "a": "b", "c": "d" }
-> "customProperties.a": "b", "customProperties.c": "d"

* Rename toolName -> name

* Rename productVersion -> version

* Let original fileVersion through without trimming off 4th part

* Use actual URI syntax for "uri" elements

* Make region start/end line/column 1-based

Adds conditional culture execution condition for tests that depend
on the culture of the machine that they are running on.  Because
we expect this culture to be in english, this patch adds a
conditional fact attribute that only runs a specified test
on a machine with the en-us culture.