* make diagnostic analyzer service lazy and not require UI thread.

require ExtensionManager change that got checked into 15.8

* change location where we log number of workspace analyzer references due to it being lazy now.

* PR feedback

* Enable switching bitness of interactive host

* Improve integration test error reporting

* Update integration test

When we were creating new metadata reference snapshots, we were reading
the timestamp far earlier than needed; all that matters is we actually
read it prior to reading it.

This change is a fairly paranoid change as I try to preserve existing
semantics (and perhaps bugs too). This area is quite sensitive.

This service tries to watch analyzer files to see if they've changed,
and if they have inform the user that they'll have to restart Visual
Studio. It did this via two ways:

1. When a file was first added, it's modification time was stored in
   a dictionary, which was checked in any subsequent entry.
2. Via file watchers.

The first approach was broken in an interesting way: each time a
reference was added, we'd add the modification time to the map (doing
the IO to get the time). This overwrote the previous value, even if
the value had changed in the middle. Then, we'd do the IO a second
time, checking against the value we had just stored. As a result, the
window where we could detect a change in the first approach was very
tiny.

I attempt to rectify what seems to be the intent here and also speed it
up. First off, we won't overwrite previous values so the first approach
has a better chance of actually working. Also, we'll read the data
once instead of twice. Further more, once the file watcher (second
approach) is active, we'll just stop reading timesetamps entirely,
because by then there's no reason to use the first approach at all.

Note this approach still has a flaw: if the file is modified between
when we do any timestamp checking, and the file watcher is active,
we'll completely miss the change and report nothing, at least until
somebody tries adding the analyzer again. This isn't new; it seems
this was already broken anyways. We could just always force the file
watcher immediately, but that might be tied up if somebody else is using
the service so we're still assuming IO is cheaper in that case.

* Change goldbar text for updating keyboard bindings

* Fix text placeholder

* Update text

* Move VS specific targets to VisualStudio.targets

* Move optimization targets to RepoToolset/OptimizationData.targets

* Move SourceLink targets to RepositoryInfo.targets

* Remove workarounds for fixed issues

* Move workrounds to Workarounds.targets

* Clean up binding redirect generation properties

* Remove unused targets

* Normalize PushToBlobFeed parameters to values used by RepoToolset.

We were calling .EnsureSubscription() right away when we add the
documents to the workspace, which was never the intent of this API;
this can (and should) be deferred until when we read the file.

This reverts commit 3bc73cab.

The target framework netcoreapp2.0 includes a new type: `KeyValuePair`.
This conflicts with our `KeyValuePair` utility class and causes a lot of
friction whenever netcoreapp2.0 is added as a target framework for a
project.

Renaming the type to `KeyValuePairUtil` to remove the ambiguity.

This isn't used by anything else.

Reduces the implicit double check for invalid characters in the path.

We were calling IVsHierarchy.ParseCanonicalName to get the item ID of
a file, to then turn around and use that to get the folder names. In
some cases, we already had the folder names so this was just silly.

Note: I update a compatibility overload for TypeScript here. They had
since moved off of the compatibility overload, so updating it and
repurposing it is safe to do.

Fixes https://github.com/dotnet/roslyn/issues/27805
Fixes https://devdiv.visualstudio.com/DevDiv/_workitems/edit/233666

Our batch load optimization in the project system interaction means
we try to avoid pushing anything but a full project, and ideally the
entire solution in one go. We were getting OnAfterLoadProjectBatch
called before we were being told about projects, which meant we'd push
an empty solution. Once we were told about projects we would then add
each project as a batch, but we'd still do O(n) WorkspaceChanged events
when one would have worked.

I'm intentionally not putting this check in
StartPushingToWorkspaceAndNotifyOfOpenDocuments because some calls
(namely the call in VisualStudioProjectTracker.FinishLoad) still need
to ensure the base solution state is pushed to the workspace even if
the solution is empty.

* move some GetServices from constructor into CreateEditorInstance()

* PR comments

* remove Package param from constructor

The AnalyzerDependencyCheckingService looks at a solution, figures out
what analyzers have potential problems, and adds diagnostics to the
error list. CheckForConflictsAsync() had to be called any time the
solution was changed in a way that might affect the analysis. This
had to be called from the UI thread, and although some of the more
expensive bits were off the UI thread, it marshalled back to interact
with the project system again. Now it's fully off the UI thread and
can be called from any thread.

Fixes Watson bug VSO [400829](https://devdiv.visualstudio.com/DevDiv/NET%20Developer%20Experience%20Productivity/_workitems/edit/400829)

Code-style only change.

This class was following the pattern where you have a mutable class that
should only be spun up, used, and immediately discarded. There wasn't
really a need, so making it static means somebody won't accidentally
use it in a thread-unsafe way.

These tests were directly invoking csc.exe out of the MSBuild path; once
MSBuild became hard to find they were skipped. Given we can just use
Roslyn to easily emit assemblies, we can remove the dependency entirely.

Previously we only trapped some exceptions from the VS file change
service, letting the rest propagate. It turns out this doesn't work
terribly well: if there is an exception, the Lazy<> we did the
subscription with will still hold onto the exception, any use of the
Lazy then rethrows. This means StopFileChangeListening/Dispose never
actually clear the underlying cookie, and we crash in our Finalizer
assert later.

Fixes #27038

* remove usings when format document

* sort usings when format document

* add code fix

* hack fix for the issue with apply multiple changes.

* refactoring

* 3 changes

1. put open file editorconfig change tracking back
2. handle open file leaking when solution close with files opened case
3. don't share locks between editorconfig events and roslyn events

* skip the 'Remove unused variable' when format document

* changed code fix part to use "fix all" and only fixes P1 list rather than fix everything in the document. also not apply changes to buffer until everything is done rather than doing it per fix.

* made undo experience better

* add expression body as one of fix to offer

* add code fix options in format document settings

* add hidden box IsCodeCleanupConfiguredCheckBox to track if the user ever configured the code cleanup

* clean up

* fix some tests

* disable a test temporarily

* PR comments

* refactoring

* Revert "3 changes"

This reverts commit 7e0fd53f02a0e20d063440b3cce5569e51e71afc.

* PR comments

* PR comments

* renaming

* bug fixing

* PR comments

* refactoring

* refactoring

* refactoring

* refactoring

* Make ICodeCleanupService extend ILanguageService

* refactoring

* refactoring

* fix deadlock, call Format inside CodeCleanupService

* rename async methods

* PR comments

* move files under features

* PR comments

* PR comments

* Never Show this again will never show the code cleanup info bar for this user.

* rename

* use ImmutableArray

This commit gets rid of having to manually track all the possible
`T`s for `CodeStyleOption<T>`, by instantiating the type via
activator.

Sadly, it uses reflection, but there is no way to make the code
function in a generic way that does not pollute the API.

Closes #20907

Fixes #18121
Fixes #23336
Closes #24248