TLDR: artifacts are going to move around in Binaries\Debug and the directory is going to get a lot bigger.

At a high level build projects can be classified into three categories based on how they write output:

- incorrect: a given output path is written to more than once with different contents
- less correct: a given output path is written to more than once but always with the same content
- correct: a given output path is written to exactly once

Today the roslyn build is decidedly “incorrect” as pretty much every file is written directly into Binaries\Debug. This means it ends up writing pretty much every Visual Studio SDK DLL twice: once for Dev14 and once for Dev15. For example at various points in the build Binaries\Debug\Microsoft.VisualStudio.Text.Data.dll may refer to Dev14 and at others it’s Dev15. If this seems like a scary proposition for a build that’s because it is indeed scary and it has real consequences. By now pretty much everyone on the team has hit the build race condition that is dragging down our PRs.

The general fix here is to move build outputs into separate directories. Instead of building to $(Configuration) projects now build into say $(Configuration)\Exes\$(MSBuildProjectFileName). This will have a substantial increase in the size of Binaries. We will be looking into ways to reduce that. In the short term though build stability far outweighs the size increase.

This change takes us most of the way to "correct". There are several places I had to compromise in order to get this initial change in:

- UnitTests still build to a common output folder (one for Dev14, another for Dev15). Pulling unit tests apart is going to take a bit of work.
- Every project has a <RoslynProjectType> entry. This will go away in the future for most projects. It's temporarily needed so I can fix roslyn-internal in parallel without taking down the build.
- VSL.Imports.targets is messy. Unavoidable for now due to the above. It will get cleaner as I iterate on this.

None of these are relevant to the underlying race condition. Hence it's okay to push them off.

The ImportGroup element is just noise.  It was also used very inconsistently in the repo and often within the same project file.  Just remove it.

This change reverts the part of #12497 that removed Concord.csproj.  This
project will now be used to express the nuget dependency on MS.VS.D.Engine
and MS.VS.D.Metadata as well as deploy the portable version for testing
(and, as the title states, set the OSS sign bit post-build).

Also, move to the latest version of the 14.3 Concord nugets (which allows
us to remove explicit <Reference> items in our portable projects).

This reverts commit f88047f5, reversing
changes made to b9438f7c.

Several of our EE binaries needed to be signed with different certificates than the standard Microsoft one.  Functionality was added to specify the certificate for the binary in question and all remaining references to the AuthenticodeCertificateName property were removed.

Several of our EE binaries needed to be signed with different certificates than the standard Microsoft one.  Functionality was added to specify the certificate for the binary in question and all remaining references to the AuthenticodeCertificateName property were removed.

We need to consume the VSSDK nugets for these assemblies in order to
build/run on a machine without VS 2015.

This reverts commit 7debfc47.

Ports the compiler generator tools (syntax generator, bound tree
generator, et al.) to .NET core and runs the exes on CoreCLR instead of
the desktop framework.

Fixes #7136

This project uses the VB syntax generator hence needs a reference to the project in order to guarantee it's built first.

closes #7869

The intent of the code base was to be run with overflow checking disabled.  However the actual settings were quite a bit different:

- CSharp: checking enabled in debug, disabled in release
- VB: checking disabled in all modes

For both languages individual projects could, and often did, override this setting.  Typically it specified the global default but not always.

This is confusing and makes it difficult to reason about our source code.  Furthermore much of our testing occurs in debug mode and it's not logical for our code to behave substantially different in Debug than it would in Release.

This change clarifies our overflow checking behavior.  It's disabled in all modes now.  The change goes further to prevent individual projects from overriding this setting and adds unit tests to make sure it was applied correctly.

Note: this PR is not intended to state whether it's better for overflow checking to be enabled or disabled.  It is intended to enforce the decision the code base was designed around.

We don't need SolutionDir or RestorePackages, which were for very old-
style restore systems.

Update 1 defaults to copying implementations for some class libraries, but we
don't need that for our feature binaries.

* This updates all references to nuget.exe to use the copy in the root.
* This deletes all NuGet.config and NuGet.exe files that are not in the root.
* This removes all references to NuGet.targets (which is obsolete and no longer exists)

The targets files were previously split into an open version in
Microsoft.CodeAnalysis.Toolset.Open and a closed version in build/. This
unifies the four targets into two new targets, VSL.Settings.targets and
VSL.Imports.targets, and moves all the targets from ..Toolset.Open into
the build/ folder.

The language-specific resource files have only one entry each. Just move
them into the shared resource file so that we will only need a single
satellite assembly.

1. Compile them against Profile7.
   a. Swap out a few APIs (e.g. using GetTypeInfo for reflection).
   b. Introduce an abstraction layer so that we don't have to instantiate
   DkmDataItem (caused a VerificationException).
   c. Include WindowsProxy.winmd as an EmbeddedResource directly, rather
   than through a resx file.
2. Swap the output locations of the ResultProvider projects: Portable goes
to the main output directory and NetFX20 goes to a subdirectory (NetFX20).
3. Include the Portable ResultProvider assemblies in the EE vsix, rather
than the NetFX20 ones.

Prior to this commit, they were identical to the corresponding desktop
(i.e. NetFx20) assemblies but now all the pieces are in place to compile
them as portable assemblies.

Cleverness: Move resources into the portable projects and link them into
the corresponding desktop projects.  The desktop projects can compile
portable designer files, but not vice versa.

We need to produce two copies of each ResultProvider DLL, one that runs on
NetFX20 and one that is Portable.  We originally believed that we could
create a single DLL that would work for both and so we just copied the
output of each ResultProvider project and signed it with a different
Authenticode certificate.  Now we know that - even though the source of
both versions will be the same - we need to actually recompile for
Portable.

As a first step, we eliminate the copying mechanism and split each
ResultProvider project in two.  To minimize duplication, we introduce
shared projects that hold on to most of the source.

The next step will be to make the two copies reference different
assemblies.