This function relied on CultureInfo which is not a supported CoreFx API.
Moved it out to the Desktop layers where it was actually used.

Binary serialization is not supported in CoreCLR and hence must be removed
from the subset which runs there.  This code is only used to support
CodeLens so rather than moving it around we are simply removing it
completely.  It will be relocated to CodeLens internally to continue supporting
their scenarios.

The Public API changes to DocumentId and ProjectId were necessary to
continue supporting serialization outside of the Roslyn code base.

closes #915

The loading of analyzer DLLS is now controlled by the compiler host.  It
is a behavior the host is forced to provide via the abstract member
CommonCompiler.AnalyzerLoadFunc.

This reverts commit b37052d0.

The primary use of DefineConstants should be to append constant values,
not replace them.  Any time a replacement operation is used it prevents
us from establishing defines in our targets and pushing them down to all
affected projects.

SourceText now includes the logic to decode efficiently from streams, throwing if binary files are detected and using LargeEncodedText to avoid the large object heap.
EncodedStringText, a shell of its former self, provides the 'desktop' entry point to detect FileStream and decode MemoryStream as byte arrays.

This change moves the contents of VisualStudioSetup into the open,
merging with (and consuming) VisualStudioComponents. The Components/
Setup split originally existed as a way to allow multiple Roslyn-using
components to have a single source of truth of the MEF exports. This
meant you could have either the interactive window, language services,
or both installed and everything worked. This was important when we
were atop Visual Studio 2013, but now that we're integrated it's buying
us nothing.

The VSIX ID from VisualStudioComponents is preserved so that way any
extensions that declared a dependency on it will still work.

1. Reduce allocations when reading from FileStream.
2. Pre-compute checksum if possible.
3. Reduce allocations for lazily computed checksums.
4. Avoid LOH allocations for large source text.
5. Update EditorTextFactory to optimize for reads from temporary storage

Perf results for the Picasso rebuild scenario:
184 MB total allocations saved. Including: 78 MB of char[], 73 MB of Byte[], 9 MB of string. Also, 35 MB of LOH allocations were eliminated.
 (changeset 1412085)

also, made ITextFactoryService internal (changeset 1406337)

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 1403394)

Update Microsoft.Net.ToolsetCompilers and Microsoft.Net.RoslynDiagnostics to version 1.0.0-rc1-20150116-01.

Also turn on the DeclarePublicAPI analyzer for all of the C# assemblies that end up in our NuGet packages. I can't turn the DeclarePublicAPI analyzer on for our VB projects yet due to bugs in the analyzer driver. (changeset 1400249)

This moves our settings / targets files into the Open directory.  These files are a referenced by virtually all of the projects in the Open directory and are a necessary part of the build process.  Making this change is a necessary step in removing the project scrubber.  (changeset 1396832)

This changeset introduces the concept of a "global" nuget package. The references to the NuGet packages are inserted into the Open VSL.Settings.targets file, which is imported into every project in Roslyn. This ensures that every project automatically gets these "global" packages. (changeset 1386548)

Updates System.Collections.Immutable and System.Metadata.Reader to versions 1.1.33-beta and 1.0.18-beta, respectively.
     Updates VSMEF to the latest build from VSPRO_1.

     A few code fixes:
     - ImmutableArrayInterop is gone
       - in product we used in a couple of places where we now just create a copy of the byte[] (MetadataWriter)
       - test infrastructure uses a workaround with explicitly laid out union to avoid copies of large metadata blobs
     - EditorTestApp class was incorrectly importing MEF components resulting in a cycle. The new VSMEF reports such errors. (changeset 1385613)

first, nobody in portable side is using Roslyn ETW event source.
second, we don't have a way to distinguish events from portable side and desktop side if two data are mixed.
third, nobody is enabling ETW in portable side.
last, ETW in portable side just doesnt work with our other tools.

so, I am moving this out to Workspace.Desktop.
 (changeset 1356327)

***NO_CI***
 (changeset 1356181)

This also updates Microsoft.Net.ToolsetCompiler to the corresponding version. (changeset 1355122)

Moved default host services logic from MSBuildWorkspace to new type DesktopMefHostServices type.

Changed CommandLineProject to make workspace parameter optional. You only need to specify workspace if want to override behavior of some of the services (beyond default).

Added WorkspaceServices.GetRequiredService and LanguageServices.GetRequiredService API that throws InvalidOperationException if service is not available.

Changed Workspace.AddDocument and Workspace.AddAdditionalDocument to take DocumentInfo instead of multiple parameters (for future proofing signature.)

Added ApplyChangesKind enum values for analyzers and additional documents

Changed Workspace TryApplyChanges to check for all unsupported changes before starting to apply.
Changed separate *apply* methods to default to calling equivalent OnXXX method instead of throwing.

Changed CustomWorkspace.CanApplyChanges to default to true for all kinds.
Added error messages for each ApplyChangesKind

Added missing WithXXX methods from DocumentInfo (changeset 1354869)

Move a few types back to the portable layer to allow a CustomWorkspace to be produced without needing the desktop layer.

As part of this, I split apart ITemporaryStorageService's ITemporaryStorage into two separate types, so it's clear whether you're storing text or storing binary streams. The merged implementation allowed some leakage of implementation details. (changeset 1353513)

Provide serializable wrappers of DocumentId, ProjectId and VersionStamp. This mirrors the SerializableProjectReference that was already in Workspaces.Desktop (and public), and the serializable wrappers of various compiler types. (changeset 1352515)

When our projects were last updated to a newer version of Microsoft.Net.ToolsetCompilers, NuGet didn't replace the old version--it just put the new version next to it. Every project ended up referencing both versions, and which set of compiler binaries "won" depended on the order they appeared in the project file. So different projects built with different compilers.

This change strips out all references to the old version. (changeset 1352054)

Previously the user had to pass both of these objects to CompilationOptions and the compiler had to call first the resolver to resolve the path specified in #r:

string ResolveReference(string reference, string baseFilePath)

and then the provider to create the reference:

PortableExecutableReference GetReference(string resolvedPath, MetadataReferenceProperties properties)

With this change the compiler simply calls on MetadataReferenceResolver:

ImmutableArray<PortableExecutableReference> ResolveReference(string reference, string baseFilePath, MetadataReferenceProperties properties)

Notice that now the resolver may return multiple references. This is needed to support #r of NuGet packages.

We used reference resolvers and providers in many ways for multiple purposes. I left behind the metadata file resolvers and providers to avoid making too many changes, but made them internal. In some cases the usage is legitimate, but still an implementation detail. More cleanup will also be possible once we remove the old scripting API. For now I have worked around all these dependencies.
 (changeset 1349333)

This change splits the Workspaces layer into two parts, mirroring the Portable/Desktop split that the compilers did. The core parts of the Workspaces layer (managing documents and projects, formatting, some refactoring, code fixes) is kept in the portable subset, with a few non-portable pieces remaining, notably MSBuild support.

This change has a major impact on how MEF now works in Roslyn. Traditional MEF (“MEFv1”) is not portable, and so we must move the Workspaces layer over to using the Microsoft.Composition NuGet package (“MEFv2”) which is. The APIs are distinct in that each has its own namespace, but the concepts are more or less identical. It requires some care though: the workspaces layer is simple in that it only references MEFv2, but higher layers have to reference both versions to use metadata attributes. Exports using metadata attributes from the editor (say, ContentTypeAttribute) must use MEFv1 attributes to export, whereas exports for the workspaces layer must use MEFv2 attributes. The rule is subtle and yet simple, and so a diagnostic is provided which catches any offenses to prevent confusion.

This also has some impact in how we create MEF hosts: if you wish to host just the base workspaces layer, we can use MEFv2 to compose everything. The HostServices implementation (MefV1HostServices) that consumes a MEFv1 ExportProvider. If you’re in Visual Studio, you can use this implementation to get the full set of host services provided in Visual Studio.

Otherwise, most of the changes in here are minor: we react to some APIs that have been moved/renamed in the portable subset we are targeting, and also align our various exception helper utilities with the compiler’s precedent. (changeset 1349276)