This change adds an OutputRefFilePath path to the workspace API for the compiler's /refout feature.

Adjust indent block operations used for VB smart indent in argument lists

* Extract common code to a helper method

Add unit test that properly covers scenario where the first argument on a line is not the first token and is split across multiple lines

Merge dev15.6.x to dev15.7.x

Enable C# emit tests on CoreClr

This conditions the use of SigningTestHeplers to only be in the net461.
In the long term this type needs to be changed to be portable friendly.
Filed the following bug to track

https://github.com/dotnet/roslyn/issues/25228

- Fixed build break in the DevDivInsertionFiles
- Fixed a couple of test failures

Key problem with the tests is they were being run in parallel. This is
due to using CoreClr which doesn't respect our .config based options.

Also fixed bad uses of Thread.Abort in the try finally tests which were
causing resource cleanup issues

147 failures remaining to handle

This updates the CoreClr test infrastructure to include verifying the
metadata signaturse of the emitted code. There is not 100% parity due to
the inability to read custom attribute data on parameters, fields, etc
... But that covers only a small number of test cases.

Destructor tests now passing.

Needed the split between the netstandand and desktop version of the
reference to be more explicit.

The ability to verify IL is presently a runtime specific operation.
Moved the logic to enforce the test conforms to the specified behavior
into the runitme layers.

Visual Basic argument lists (and other parenthesized lists, like parameter lists and type parameter lists),
have specialized smart indent behavior. Essentially, arguments after the first argument in a list are
indented to the same position as the first argument. Consider the following code.

``` VB
Sub M()
    Console.WriteLine("{0} + {1} = {2}", 19, 23, 19 + 23)
End Sub
```

If the user presses ENTER before the second argument (19), the indentation looks like so.

``` VB
Sub M()
    Console.WriteLine("{0} + {1} = {2}",
                      19, 23, 19 + 23)
End Sub
```

However, this can cause indentation issues if the user wants to ident all subsequent arguments differently.
Consider the following scenario.

``` VB
Sub M()
    Console.WriteLine("{0} + {1} = {2}",
        19, 23,
        19 + 23)
End Sub
```

Now, if the user presses ENTER before the third argument (23), the indentation of the first argument will be
used, even though the user had indented the second argument differently:

``` VB
Sub M()
    Console.WriteLine("{0} + {1} = {2}",
        19,
                      23,
        19 + 23)
End Sub
```

This problem occurs because a single indent block operation is created for the whole argument list using the
indentation of the first argument. This change fixes the issue by creating multiple indent block operations
using the indentation of the first argument, and the indentation of any argument that appears on a different
line.

* Refactor Windows PDB writer

Remove NFW causing delays

Move checking of structure-options to a common location (so it will be picked up by all roslyn languages).

* Move common parts of Microsoft.CSharp.Core.targets and Microsoft.VisualBasic.Core.targets to Microsoft.Managed.Core.targets

Add a comment to make it clear that we don't expect other projects to
still be referencing the project being `Disconnect`ed, and why we're
protecting against it.

Merge 15.7.x features/compiler work into the dev15.7.x 

Remove a non-fatal Watson report that was triggering frequently and
causing UI delays. We expected that all references to a project would be
removed before the project itself was unloaded, and this report was
added to help us diagnose the rare occasion when that did not occur. It
turns out that it happens quite frequently: when a solution closes, when
a project changes externally and needs to be reloaded, and when a
project is deleted from the solution. We're getting a lot more of these
events than expected, and worse, collecting the Watson data sometimes
causes long pauses in the UI.

We do not have a concrete plan for dealing with the underlying issue,
but the data we've already collected from these reports demonstrates the
scope of the problem and collecting more won't help at this point. Since
the collection itself is causing problems, it's time to just remove it.

* enable logAnalyzerExecutionTime on IDE so that we can start track analyzer perf

* removed unnecessary ICodeAnalysisDiagnosticAnalyzerExecutor interface.

it was added when OOP is first introduced to make sure VS.Next dll won't get loaded to VS process if OOP is not enabled.

when it is enabled by default, rather than removing the interface, implementation just moved down to feature layer to reduce code churn.

now, I am properly removing unnecessary abstraction.

* take Executor out of test MEF composition

* added IRemoteDiagnosticAnalyzerService interface

* made initial version working.

* added tests

* add tracking for inproc only analyzers

* pass in diagnostic analyzer service

* added open file performance tracking as well.

* added PII test

* dont hash analyzerId when it is reported by internal user

* added link to LOF wiki

* made blame to track open files as well.

* forgot to add return in if statement

* reduce threshold to 100ms

decide to start from lower threshold and then iterate rather than start from higher threshold

* added a way to log real time perf data in local machine with explicit option which can be used to train formula later

* addressed ivan's feedbacks

* renamed to ExpensiveAnalyzerInfo

* addressed PR feedbacks

* more renames

* addressed PR feedbacks.

renamed as much as I can find.

* listener can be null in unit test

* addressed PR feedbacks

Return FormattableString for BoundTupleExpression.Display/BoundStackAllocArrayCreation.Display and allow FormattableString in DiagnosticInfo.Arguments.