* Clean up string resources, use Arcade resx generator

* CodeLens resources


* Use NET20 instead of NETFX20

fix for language code capitalization

* MonoGlobalAssemblyCache: actually read assembly names from assembly files

new AssemblyName(path) becomes AssemblyName.GetAssemblyName(path)

This fixes the GlobalAssemblyCacheTests when running on Mono.

cf. https://github.com/dotnet/roslyn/pull/39369#issuecomment-545970358

* MonoGlobalAssemblyCache: faster resolves + resolve Facades

1. Don't special case mscorlib.dll - we already will have a reference
   to it, and the changes in (2) allow it to still resolve. Remove
   GetCorlibPaths.

2. Have GetCacAssemblyPaths bail early if it finds an assembly that
   lives alongside mscorlib.dll, or in the Facades directory. This
   These assemblies in Mono are considered "core" and will always
   symlink directly to the GAC. Resolve facade assemblies as well now.
   The Mono distribution of csi has shipped with a response file that
   explicitly referenced Facades/netstandard.dll and
   Facades/System.Runtime.dll and this change obsoletes that. As a
   consequence, local builds of csi.exe now work.

3. Minor perf work around converting a public key token to a string by
   deferring that conversion until only necessary, and use byte.ToString
   instead of AppendFormat. Also use a PooledStringBuilder.

4. Tuple -> ValueTuple

* MetadataShadowwCopyProviderTests: run on Mono

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

This enforces the use of `Assert.Null` or `Assert.NotNull`

* Misc cleanup

* Reuse previously resolved missing assembly metadata objects when identity doesn't match

Background
When the compiler is resolving compilation references and encounters a reference whose assembly identity does not match any of the explicitly given references it falls back to a Reference Resolver. In regular compilation an error is reported since there is no Reference Resolver. Interactive compiler supplies a resolver that attempts to find the missing reference.

Once the missing reference is found the compiler adds it to the list of implicitly resolved assemblies and if the same missing assembly identity is referenced later (by a subsequent submission) it reuses the assembly symbol from this list, so that we don't end up loading multiple instances of the same missing assembly. [1]

The resolver may find an assembly that matches the name of the missing reference but doesn't match the version exactly. This is expected as a newer version of the assembly may be available than was referenced and the compiler correctly binds to the newer version.

Issues
The first submission added a reference to a netstandard20 library on .NET Core and the subsequent submission referenced a type from that library. The reference resolution in the compilation corresponding to the second submission ended up adding a new, distinct reference to the library, instead of reusing the one that was already resolved for the first submission compilation.

This was caused by mismatch in versions of some of the facades transitively referenced by the library thru netstandard.dll reference and resolved thru the missing reference resolution mechanism. The facades ware referenced with different versions than the actual versions available in the set of references the Reference Resolver resolved missing references from. The compiler ended up using two distinct instances of the same facade assembly metadata. An assembly symbol is only reused if all its transitively referenced assemblies match. In this case the library assembly symbol wasn't reused because some of the facade assembly symbols did not match.

The problem was that the mechanism [1] didn't reuse missing assembly metadata with a different version than what was requested. The fix is to check whether we have seen an assembly with the resolved identity in addition to the requested identity.

Another issue found during testing is handing resolution failures. We did not remember that a resolution of a given assembly identity failed and attempted to resolve the assembly again in the next submission. This may lead to inconsistencies and the same "can't convert T to T" errors since first submission might have a missing assembly symbol and next might create a real assembly symbol for the same assembly identity. The fix is to capture both successful and failed resolution results.

* Do not add resolved identity entry to implicit reference resolutions

Fixes #32576. Fixes #33564.

Microsoft.CodeAnalysis.Scripting now targets NS2.0, so the custom package is no longer needed.
Should fix a composition error in VSMac, due to the fact that we don't ship the dll from this nuget

* include exception type in CommonObjectFormatter for scripting/interactive

* fixed tests

Closes #35090

Closes #35072

* Remove RoslynProjectType

* Remove ToolsVersion, namespace from Project tags

* Remove updating of MSBuildAllProjects

* Update BuildBoss

* Delete DeployTooolsetCompiler

See #5661

See #35090

See #35072

* Analyze nullability in script initializer

* C# 8 for scripts for now

* nullable context script test

* extra null check

* added possibility to set c# Language Version on ScriptOptions

* adjust tests

* added ScriptOptionsTests for C# lang version

* adapted tests after rebase

* code review changes

* fixed test names & resx CDATA

* changed the ScriptOptions.WithLanguageVersion error message text and moved it to ScriptingResources.resx

* Update CSharpScriptingResources.Designer.cs

* Revert "Revert "Interactive projects refactoring (#29069)""

This reverts commit e0a8124f.

* Fix bad merge

This reverts commit 41fb51d2.