- VB: Report a warning about AssemblyKeyFile and AssemblyKeyName attributes being ignored by public signing.
- Disallow public signing for Net modules. The fact that the signing is public is not preserved in a module. The fact of signing is preserved by emitting attributes that are going to be ignored anyway if public signing is used.

Closes #11427.

The Compilers.sln solution is compiling again and tests which don't
require AppDomain support are running again.  There is a bit of work
that is needed for AppDomains that I want to separate out.  In
particular the separation to portable means we have to redo some of the
serialization code.

Roslyn uses the CLR APIs to sign an assembly, so as long as the CLR
supports the key length and it is a valid key structure there's no
reason we should limit the length of the key. In addition, the previous
limit was wrong -- it didn't include padding space for the key header.

Fixes #12822

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.

Also adds tests for this case. Right now /delaysign silently wins.

Fixes bug #7734.

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.

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.

Fell out of our normal cadence for this during the push for RTM. Now that we
had a bit more breathing room getting us back on track here.

This change is meant to address crashes like the ones in bug 1140649. The
crashes seem to happen due to exceptions thrown while getting a temporary
output stream to write the PE file to. I have been unable to reproduce
the conditions for the crash themselves -- they only seem to happen on
a Japanese language Windows with a Japanese language copy of Visual Studio.
This fix addresses their symptom by wrapping the CreateInputStream call
during signing with a try/catch and then surfacing the exception as a
diagnostic for signing failure.

We cannot currently add any more localized resources to stabilization, so
this fix is meant to be as targeted as possible and can only deliver
information through existing resource strings.

(cherry picked from commit 801a10a5)

This change is meant to address crashes like the ones in bug 1140649. The
crashes seem to happen due to exceptions thrown while getting a temporary
output stream to write the PE file to. I have been unable to reproduce
the conditions for the crash themselves -- they only seem to happen on
a Japanese language Windows with a Japanese language copy of Visual Studio.
This fix addresses their symptom by wrapping the CreateInputStream call
during signing with a try/catch and then surfacing the exception as a
diagnostic for signing failure.

We cannot currently add any more localized resources to stabilization, so
this fix is meant to be as targeted as possible and can only deliver
information through existing resource strings.

Enable hosts to compile strong-named assemblies on all platforms by supplying public key via compilation options and also enable OSS signing with such key

Been almost a month since the code formatter was run so this change was
a bit larger than would be expected for a normal (weekly) update.  Diffs
mostly around:

- Whitespace changes
- Missing copyright headers
- Missing visibility modifiers

Fix #409:
Add explicit StringComparison.Ordinal or StringComparison.OrdinalIgnoreCase where it was intended,
or replace single-char string literals with chars literals.
Also, provide InvariantCulture in TryParse where it was intended.

A bit of cleanup of assembly signing interop interfaces making the code portable. (changeset 1412135)

There are cases where underlying platform does not provide signing services in the form that we consume. We need to be able to handle such cases gracefully without crashes.
***NO_CI***
 (changeset 1412127)

     Background:

     As discussed in the dev team all hands all code under the GitHub dotnet foundation is using a single process for contribution, API review, infrastructure and coding style. The idea is to present a unified view to our customer and give them a single story for contributing to any project under the dotnet foundation.

     https://github.com/dotnet/corefx/wiki/Contributing#c-coding-style

     The coding style transition is automated using a Roslyn based rewrite tool:

     https://github.com/dotnet/codeformatter

     This will be applied in stages across our developer tree. Right now the focus is on the Open directory as this is what is being presented on github. Code owners will be contacted before the transition happens.

     Note: this is a soft style requirement. There are no build errors that come from this change.
 (changeset 1408227)

ByteSequenceComparer has been updated as follows:
- The implementation of IEqualityComparer<IEnumerable<byte>> has been removed
- The implementations of IEqualityComparer<{byte[], ImmutableArray<byte>}> are now explicit
- The various overloads of EqualsValue and GetHashCodeValue have been renamed to Equals and GetHasCode, respectively.
***NO_CI***
 (changeset 1395450)

 Make tests passing on a non-English OS, even in presence of corresponding localized resources. In the process several product issues were fixed like:
     - Localized exception messages incorporated into diagnostics by command line compiler are not obeying /preferreduilang switch.
     - Some strings are loaded from resources at the time when diagnostic object is created. Resources are loaded earlier than they could be. When error message is requested, it might not be localized in accordance with the requested culture.
     - When target culture is not provided, DiagnosticInfo objects used as arguments within another diagnostic object are formatted using InvariantCulture, whereas all other arguments use current culture (as expected). Portions of the message are localized to different languages. (changeset 1392630)