Make CodeModel.CodeTypeFromFullName rational when returning types that appear in generated code files

Ensure that FormattableString is preferred by Introduce Explaining Variable and Extract Method

Prevent duplicate invocations of per-compilation analyzer actions for a given symbol/syntax node in IDE.

User scenario: An analyzer author writes a compilation end analyzer, which registers symbol and/or syntax node actions to maintain some state about them, and a compilation end action to report diagnostics based on the final sate. When running in the IDE, the analyzer will get duplicate callbacks to the symbol/syntax node actions for the same symbol/node in the compilation: once while computing active document diagnostics and once while computing project diagnostics. This can cause one of the following issues:

  1. Crash the analyzer if it is using some map keyed on the callback symbol/node, and doesn't handle duplicate callbacks.
  2. Corrupt the analyzer state by recording the state twice for a single symbol/node.
  3. Possibly cause the analyzer to enter a race or deadlock.

Fix Description: Fix is to ensure that when computing the compilation end diagnostics for such stateful analyzers, we use a new instance of the analyzer. All the compilation wide actions are then invoked on this new instance of the analyzer, avoiding duplicate callbacks into the same instance.

Fixes #248 

Testing: Added a regression test + existing tests.

Approved 5/29 by ML Shiproom.

Improve performance of IVsLanguageDebugInfo.GetNameOfLocation...

Previously, we would fetch a SemanticModel and build containing Symbols
for each breakpoint location.  This could be very expensive in a large
solution.  However, for the purposes of providing parity with the old
implementation, it is adequate to just inspect Syntax.

(fixes #1977)

Do not localize diagnostic severity in the diagnostic formatter

Fixes internal bug 1093063: 'csc2.exe'/ 'vbc2.exe' will ICE (exit with Code 1) when trying to report errors on localized installs

User scenario: Create a default VB/C# project on a localized OS, introduce some errors/warnings and build the project from the command line through msbuild.
Expected: Compiler diagnostics show up in the build output.
Actual: No diagnostics are displayed, and msbuild exits with code 1.

Fix Description: MSBuild tasks have a specific parsing logic to look for non-localized diagnostic severity strings such as "error" and "warning" in the compiler output to detect errors and warnings. Our diagnostic formatter was localizing these severity strings, causing the msbuild parsing to fail on localized OS. Fix is to match the Dev12 compiler behavior by not localizing the severity strings.

Testing: Added regression tests + existing tests

Fixes internal bug 1093063: 'csc2.exe'/ 'vbc2.exe' will ICE (exit with Code 1) when trying to report errors on localized installs

User scenario: Create a default VB/C# project on a localized OS, introduce some errors/warnings and build the project from the command line through msbuild.
Expected: Compiler diagnostics show up in the build output.
Actual: No diagnostics are displayed, and msbuild exits with code 1.

Fix: MSBuild tasks have a specific parsing logic to look for non-localized diagnostic severity strings such as "error" and "warning" in the compiler output to detect errors and warnings. Our diagnostic formatter was localizing these severity strings, causing the msbuild parsing to fail on localized OS. Fix is to match the Dev12 compiler behavior by not localizing the severity strings.

Testing: Added regression tests + existing tests.

Emit DebuggerStepThroughAttribute on async kick off method in order to improve stepping behavior during debugging.

CodeModel.CodeTypeFromFullName should prefer locations within source
files that are not generated (using the same heuristic we use within the
Generate Type dialog to determine whether a source file is "generated").
However, if the locations are *all* within generated sources, just
return the first one.

Scenario: this addresses a scenario where CodeModel.CodeTypeFromFullName
is used to determine the right place to modify user code. In the case of
XAML apps, there are several generated files that shouldn't be modified
(i.e. .g.i.cs .g.cs, etc.). Previously, CodeTypeFromFullName might
return one of these files as a location, breaking whatever feature was
trying to modify the user's code.

Unit tests have been added for this scenario in C# and VB that test a
handful of permutations of generated and non-generated code with partial
classes. Additionally, the Code Model unit testing infrastructure has
been updated to support TestWorkspaces with multiple documents.

don't try to create an outlining span if valid start/end tokens can't be found

When extracting an interpolated string that is target-typed to
FormattableString, the resulting declaration should use
FormattableString as the type rather than string. Otherwise, the result
is uncompilable code.

prevent duplicate signature help items from surfacing to the UI

Don't restart on failed connection sequence

Port: Handle rename decl conflicts when decl file contains no refs

Emit DebuggerStepThroughAttribute on async kick off method in order to improve stepping behavior during debugging.

Addresses DevDiv 1173179.

Handle out parameters in cross-language scenarios

Ignore the difference between ref and out in ```SymbolKey``` and
```SymbolEquivalenceComparer``` since two overloads cannot differ by only
RefKind.  This prevents VB FAR and GTD from being too discerning and
missing matching references.

Caveat: Switching between ```ref``` and ```out``` is still a rude edit, so EnC sets a
switch to force consideration of the difference.

Fixes #599.

This could cause weird issues where sig help would have the first item
highlighted then trying to use the arrow keys to navigate the list would
always reset to the top item and it would appear to the user that their
arrow key presses were being swallowed.

The only case where duplicate items could appear in the list are during
error cases, so nothing is lost from the user's perspective.

Fixes #2352

This change fixes a rename crash that would occur when a method
declaration conflict was introduced in a file with no references to that
symbol, but where at least one other document in the same project had a
reference to that symbol.

When processing an individual project in ResolveConflictsAsync, we start
with the full set of documents from _documentsIdsToBeCheckedForConflict
related to that project. But, each rename phase can adjust this set of
documents (called documentIdsThatGetsAnnotatedAndRenamed locally) to
whatever documents are represented by the current set of
_conflictLocations, which can exclude the
_documentIdOfRenameSymbolDeclaration itself if it contains no
references. Now, when documentIdsThatGetsAnnotatedAndRenamed is
recalculated we make sure to keep the
_documentIdOfRenameSymbolDeclaration in the set if we're processing the
project that contains it.

The mapping to metadata should use the original anonymous type map, not the map translated to the previous generation

Avoid using GetEntireImage for detecting empty images as it maps the entire PE into memory in case of memory mapped PE image

Port: TypeInferrer: Infer types in collection initializers 

Remove superfluous sequence point emitted by VB await spiller

Add Roslyn to build task so GAC'ing isn't necessary for IDE.

Prevent duplicate invocations of per-compilation analyzer actions for a given symbol/syntax node in IDE.

User scenario: An analyzer author writes a compilation end analyzer, which registers symbol and/or syntax node actions to maintain some state about them, and a compilation end action to report diagnostics based on the final sate. When running in the IDE, the analyzer will get duplicate callbacks to the symbol/syntax node actions for the same symbol/node in the compilation: once while computing active document diagnostics and once while computing project diagnostics. This can cause one of the following issues:

1. Crash the analyzer if it is using some map keyed on the callback symbol/node, and doesn't handle duplicate callbacks.

2. Corrupt the analyzer state by recoring the state twice for a single symbol/node.

3. Possible cause the analyzer to enter a race or deadlock.

Fix Description: Fix is to ensure that when computing the compilation end diagnostics for such stateful analyzers, we use a new instance of the analyzer. All the compilation wide actions are then invoked on this new instance of the analyzer, avoiding duplicate callbacks into the same instance.

Fixes #248

Testing: Added a regression test + existing tests.

Fixes internal TFS bug #529480

Normalize references to Microsoft.VisualStudio.Composition

Port: Don't assume rename text parses as IdentiferNameSyntax

Avoid using GetEntireImage for detecting empty images as it maps the entire PE into memory in case of memory mapped PE image

Introduce variable for an expression whose parent is a conditional access expression. Fixes internal bug 1130990.

Clone of approved PR: #2414

The mapping to metadata should use the original anonymous type map, not the map translated to the previous generation

This contains two small rename fixes related to invalid rename text:
1. In OnTextBufferChanged, we were trying to ensure that the
intersection of the tracked rename spans and buffer changes was a single
span. However, when the rename text is invalid, there can be many buffer
change spans that intersect a single tracked rename span, so we now use
the least bounding span of the resulting intersection. We maintain the
requirement that this bounding buffer change span intersect a single
tracked rename span.
2. When the rename text is invalid, we display it in the Rename
Dashboard. This change adds the same truncation algorithm already
applied to the original symbol name (which reduces it to 15 characters
and appends a "..." if necessary).

Fixes #1031

In both the C# and VB RenameRewriterLanguageServices, we were assuming
the new rename text would parse as an IdentifierNameSyntax, but if the
rename text is invalid it could parse as anything. For example, if the
user tries to rename "A" to "A.B", then it will parse as a
QualifiedNameSyntax. We now accommodate these cases.