Signed integer compression in PE Writer was implemented incorrectly. Fix the implementation. This didn't actually affect anything Roslyn currently emits since we are only using this compression to encode low bounds of arrays, which are always 0 in C# and VB.
     Support arbitrary negative syntax offsets in EditAndContinueMethodDebugInformation. Rather than using signed integers to encode the negative values, which increases the size of the data for the majority of cases when the offsets are positive, we encode a baseline and add it to the offsets. (changeset 1365821)

***NO_CI***
 (changeset 1365691)

Use the same algorithm for state machine type name generation for iterators that is used for async in both C# and VB.
Preserve the name of the state machine when emitting EnC delta. (changeset 1365145)

and additional compatibility tests (changeset 1365001)

Change CalculateLocalSyntaxOffset to be an abstract method instead of a virtual that throws. (changeset 1364995)

When using Rename Tracking to rename "Abc" to "Abcdef", the RenameTrackingCommitter first rolls back the locally changed identifier, in this case back to "Abc", before calling RenameSymbol. For linked files, the RenameTrackingCommitter was only updating this identifier in the current context document which caused an inconsistent solution to be passed into the Rename API. We now roll back the identifier changes in all linked documents before calling RenameSymbol.

Additionally, the underlying LinkedFileReferenceFinder now defends against inconsistent APIs in the event one is passed in. (changeset 1364246)

Hoist all long-lived (user-defined and synthesized) variables to state machine fields in debug builds.

In order to provide good debugging experience and enable EnC of async and iterator methods we need to lift locals whose lifetime may span state machine suspension points to fields of the state machine.

For example,

IEnumerable<int> Enumerate() { int x = 1; F(x); yield return 1; }

might be changed to

IEnumerable<int> Enumerate() { int x = 1; F(x); yield return 1; G(x); }

during debugging (or G(x) might just be evaluated in EE while the program is broken on a breakpoint following the yield statement) and thus x has to be hoisted upfront even though it’s lifetime doesn’t cross suspension point in the initial compilation.

In addition to lifting the locals we also need to generate an EnC map for them (syntax offset + debug id + type -> slot index), so that we can reuse the state of existing locals during EnC.

The implementation is similar to unhoisted local variable mapping and exploits an existing notion of “slots” used by the EE to encode local scopes of hoisted variables.
All hoisted variables are assigned slot indices in a syntax order (just to make it deterministic, the order doesn’t matter). The variables are hoisted to fields with names <>5__N (user-defined – this name pattern is already recognized by both Dev12 and Roslyn EEs) and <>s__N (synthesized). N is a slot number. For these locals we emit EnC custom debug information in the same format as we do for unhoisted locals. We attach this CDI to the iterator/async method.
 (changeset 1364072)

Fix for bug 880044: Code fixers should not use diagnostic ID to distinguish between different cases of the same diagnostic

Fix is to use custom tags to differentiate between cases of same diagnostic generated by CA1008 diagnostic analyzer. (changeset 1363529)

***NO_CI***
 (changeset 1363488)

CodeFixProvider:
1. "Task<IEnumerable<CodeAction>> GetFixesAsync(CodeFixContext)" becomes "Task ComputeFixesAsync(CodeFixContext)".
2. CodeFixContext now has a new method - "void RegisterFix(CodeAction, IEnumerable<Diagnostic>>)".

This API now allows providers to map each returned code action to the set of diagnostics being fixed by this code action.

CodeRefactoringProvider gets identical API changes for consistency:
3. "Task<IEnumerable<CodeAction>> GetRefactoringsAsync(CodeFixContext)" becomes "Task ComputeRefactoringsAsync(CodeFixContext)".
4. CodeRefactoingContext now has a new method - "void RegisterRefactoring(CodeAction)".

Also moves all our existing fix and refactoring providers (including samples and sdk templates) over to the new API. (changeset 1363085)

Do not mark BoundBlock associated with ArrowExpressionClause as compiler generated. This ensures SemanticModel does proper caching for this node. (changeset 1362639)

make Task.Run to accept cancellation token and for Task.Run accepts Task, make sure that runs from background thread as well. (changeset 1362382)

We offer cast removal for case where expression type and outer type are identical and cast to outer type is widening reference conversion. However, we also need to check if expression to cast type is not a narrowing reference conversion as that can cause cast removal to change the runtime value of the expression. I also fixed an incorrect test that was verifying the current behavior. (changeset 1362323)

Ensure that warning level for non-error diagnostics is non-zero. This is required for backward compat, as the only way to suppress warnings in C# used to be /warn:0.  If user has command line with /warn:0, they should continue to only see errors in their output. Prior to this change, we also show info messages in the output. (changeset 1362306)

 (changeset 1361991)

 (changeset 1361879)

Replace usage of IEnumerable<byte> with ImmutableArray<byte>. (changeset 1361322)

One paragraph in the comment for SourceMethodSymbol.LazyMethodChecks was very confusing to me.  The commented out SpinWaitComplete code was simply incorrect given the fact that LazyMethodChecks is reentrant.  Instead, I clarified the reentrancy and explained why it would be incorrect to assert that when we exit the method via the else case, FinishMethodChecks is true. (changeset 1361245)

Fix for bug 1069573: Roslyn crashes due to "Found invalid data while decoding" even without any analyzers/code fix providers imported.

The crash happens when attempting LoadTextAsync for non-text additional documents in a project file. We throw an InvalidDataException for this scenario, bringing down VS. This fix guards against the crash by defaulting to an empty text document for non-text files. In future, when we add support for non-text additional documents, such that they are based on a non-text document state, this change will be reverted. (changeset 1361214)

This is adding telemetry that will enable us to count the different kinds of analyzers that people will write (syntax\semantic – stateful vs stateless etc.)
The change is in the execution part of analyzers as opposed to the registration part because the registration part is in the Open side of the compiler and we do not have any telemetry infrastructure in place yet to handle the Open part of the compiler. This has passed perf test runs. (changeset 1361005)

Bugfix 1068445 - Added a Null Reference check to the C# Elastic Trivia Formatting Rule (changeset 1360484)