This one was straightforward. There were just a couple of transgressions - both easily fixed. (changeset 1408016)

      Build new VSIX which contains just the interactive window
      Rename interactive window assemblies
      Include new VSIX in the list of files to be inserted

     Public API cleanups
      Move command constants into commands namespace
      Move operations onto IInteractiveWindowOperations interface
      move IContentTypeMetadata to internal class
      Make InteractiveContentTypeNames internal, move constants to InteractiveConstants
      Make RestoreHistoryEditTag internal
      Make CommandIds internal
      Make Guids internal
      Fix AV when opening interactive window (changeset 1407986)

Now that Matt has gone through the fxcop fixers and switched them to use SyntaxGenerator, we can remove IVT from workspaces - i just needed to add a few simple helpers - nothing unreasonable. (changeset 1407864)

      Build new VSIX which contains just the interactive window
      Rename interactive window assemblies
      Include new VSIX in the list of files to be inserted

     Public API cleanups
      Move command constants into commands namespace
      Move operations onto IInteractiveWindowOperations interface
      move IContentTypeMetadata to internal class
      Make InteractiveContentTypeNames internal, move constants to InteractiveConstants
      Make RestoreHistoryEditTag internal
      Make CommandIds internal
      Make Guids internal
      Fix AV when opening interactive window
 (changeset 1407857)

Make default implementation of GetRootAsync return the root node synchronously (rather than calling Task.Factory.StartNew).  SyntaxTree implementions that want to schedule work concurrently, etc, should override GetRootAsync.

Calling Task.Factory.StartNew with an arbitrary (current) scheduler may cause deadlocks.

Consider the case where some code calls GetRootAsync, and that method returns before the Task returned by StartNew is actually scheduled/executed.  If the caller subsequently calls Task.Wait, and the scheduler decides to "inline" the execution of the Task (execute on the same thread), then there will be a deadlock. (changeset 1407810)

Add a Roslyn diagnostic for C# and VB code analysis projects to verify that all of the expected source symbol types have some code path that generates a SymbolDeclaredEvent. This will hopefully avoid bugs such as 1111667 (Cannot develop VB analyzer when field does not have an initializer) in future. (changeset 1407683)

This particular exception in Dispose is masking a real failure in our suite runs.   This particular scenario can only happen, based on my code reading, if an exception happens trying to create the RuntimeAssemblyManager instance.  In that case domain != null && assemblyManager == null.   That exception propagates out the calling code which has HostedRuntimeEnvironment in a using block hence it goes to Dispose.  The Dispose method thinks this combination is invalid and throws a new exception thus hiding the real and original problem.

     Removing the check in Dispose so the real exception will make it into our xUnit logs and we can track down the flaky behavior. (changeset 1407359)

1) Change MethdCompiler.BindMethodBody to associate correct syntax with BoundBlocks it creates when binding constructor with constructor initializer call (two bound blocks are created – outer one defines a closure scope for constructor parameters, the inner one defines a closure scope for variables in the body).
2) Introduce MethodDebugId – a method ordinal and generation ordinal pair
3) Introduce LamdbaDebugInfo and ClosureDebugInfo to represent information (syntax offset) we use to figure out how to map lambdas and closures to the previous generation.
4) Adds a new PDB CDI record (#7) to store lambda and closure debug info.
5) Generalizes CalculateLocalSyntaxOffset to handle positions in field/property initializers and constructor initializers. Use it to calculate syntax offsets of lambdas and closure scopes. (TODO: rename CalculateLocalSyntaxOffset to CalculateSyntaxOffset).
6) Replace lambda and scope ordinal dispenser integers with array builders that collect LambdaDebugInfo and ClosureDebugInfo.
7) Use TryGet- pattern for all VariableSlotAllocator APIs.
8) Implements mapping of lambda method and display class names to previous generation via VariableSlotAllocator.
 (changeset 1407240)

If an assembly has "global" alias don't qualify namespace name in PDB with an extern alias. (changeset 1407218)

Remove unused CommandLineSplitter class and update unit tests. (changeset 1407192)

This is because peek uses symbolkeys to resolve symbols between compilations which could potentially be from different frameworks but symbolkeys do not contain enough information to deal with typeforwarding situations. E.g: a portable project and a non-portable project may both resolve the same Int32 symbol to System.Runtime and mscorlib.

Other features such as Metadata as source, Find References already do this. This change updates Peek to do the same thing. (changeset 1407182)

Don't worry, the Squirrel of Chain is already in my possession.   (changeset 1407173)

If you call Task.Factory.StartNew and use one of the overloads that doesn't take TaskScheduler, the resulting task is scheduled onto TaskScheduler.Current. This is very dangerous in a free-threaded library like Roslyn: if the function runs on the UI thread it's possible the resulting Task will be scheduled on the UI thread accidentally. If later UI code were to wait on that task or a continuation of it, we might deadlock.

The solution is just to ban the APIs -- if somebody wishes to schedule to the current thread, it's up to them to be explicit. Otherwise, TaskScheduler.Default should be used. (changeset 1407143)

The C# compiler was not using the correct syntax node to verify whether or not the expression body of an expression-bodied lambda or member was classified as a statement expression. This caused code to unexpectedly succeed to compile in certain cases (e.g. when the expression body was a parenthesized-expression that wrapped a valid statement expression), which broke conversions to void-returning delegates (and thus overload resolution, as in the original repro). This change adjusts the check to use the correct syntax node.
***NO_CI***
 (changeset 1406995)

Background:

As discussed in the dev team all hands all code under the GitHub dotnet foundation is using a single process for contribution, API review, infrastructure and coding style. The idea is to present a unified view to our customer and give them a single story for contributing to any project under the dotnet foundation.

https://github.com/dotnet/corefx/wiki/Contributing#c-coding-style

The coding style transition is automated using a Roslyn based rewrite tool:

https://github.com/dotnet/codeformatter

This will be applied in stages across our developer tree. Right now the focus is on the Open directory as this is what is being presented on github. Code owners will be contacted before the transition happens.

Note: this is a soft style requirement. There are no build errors that come from this change. (changeset 1406961)

This affects what happens to tags for previous text snapshot versions that are mapped forward (in the interim period before we get the new up to date tags).

Most features just have EdgeExclusive behavior.  However, some features, like TypeScript classification, want EdgeInclusive behavior so that if you type at the edge of an existing tag, the next text gets the old classification and does not flash.
***NO_CI***
 (changeset 1406469)

Rollback SkipApplyOptimizations change for Features and BasicEditorFeatures (to see if issue with ibcmerge has been fixed)...
***NO_CI***
 (changeset 1406462)

also, made ITextFactoryService internal (changeset 1406337)

This change introduces an overload of the LocalizableResourceString constructor which does not take any formatting arguments.

Memspect reported over 3,000 instances of zero-length string arrays being created for constructing LocalizableResourceString.

Microsoft.CodeAnalysis.CSharp.dll!Microsoft.CodeAnalysis.CSharp.ErrorFacts.GetTitle
Microsoft.CodeAnalysis.CSharp.dll!Microsoft.CodeAnalysis.CSharp.ErrorFacts.GetDescription
Microsoft.CodeAnalysis.CSharp.dll!Microsoft.CodeAnalysis.CSharp.ErrorFacts.GetMessageFormat (changeset 1406198)

Bugfix 1086632 [RenameSymbolAsync] throws exception when renaming multiple symbols using a solution object / Crash when invoking EncapsulateField on multiple static fields

These exceptions and crashes were happening because rename was leaving annotations on nodes even after the rename operation was complete. The ConflictEngine already had a method to RemoveAllRenameAnnotations, but it failed to remove annotated nodes or tokens nested inside other annotated nodes.

This change updates RemoveAllRenameAnnotations's call to SyntaxNode.ReplaceSyntax to use computeReplacementNode & computeReplacementToken functions that utilize the "updated" node instead of the "original" node when calculating their replacements, which then preserves any earlier changes to descendant nodes/tokens. (changeset 1406014)

The Open directory contains several projects that rely on having a compatible version of Visual Studio 2015 installed in order to build properly.   At this time there is no version of Visual Studio that will work over the long term that we can ask customers, and Jenkins, to move to in order to edit and build Roslyn.sln on master.  Our dependency on the VS SDK just evolves too rapidly.

After some discussion I decided to put two solution files into the repo:

     - Roslyn2013.sln:  This solution is usable on a machine with only Visual Studio 2013 installed.  This unfortunately won't contain all of the new items we are releasing but at least gives customers a stable base to iterate on.
     - Roslyn.sln: This solution contains every project we've released and will work with some builds of 2015.  Likely it will work with the most recent CTP but I have not verified that (just don't have the right setup to do so).

The long term plan here is to always be able to edit, build and debug the master branch with an RTM version of Visual Studio.  But until we hit RTM (or really RC) of Visual Studio 2015 we are going to have a hybrid solution to keep both us and customers productive.   (changeset 1405691)

The compiler emits catch-all handler to all async methods. In case of async void methods we also emit the offset of the catch handler to PDB, so that the debugger can pretend that exceptions thrown by the async method are unhandled. Otherwise they are lost. Currently the compiler emits wrong offset, so the debugger is completely confused and displays "no source location" when such exception occurs.

     The fix is to remove a synthesized "nop" instruction that was incorrectly used to track the catch handler IL offset. Instead mark the synthesized BoundCatchHandler node by a flag and create the IL marker in the CodeGen when emitting instructions for such bound node.

     Affects both C# and VB.

     Fixes bug 1114809. (changeset 1405564)

Add LambdaExpressionSyntax node as an abstract base class of SimpleLambdaExpression, ParenthesizedLambdaExpression.
Add AnonymousFunctionExpression as an abstract base class of LambdaExpressionSyntax and AnonymousMethodExpression.
 (changeset 1405438)

Brace matching has code to check for matching spans left of the caret - to deal with cases like {$$()}. We need to protect against negative numbers when caret is at position 0. (changeset 1405386)

 (changeset 1405366)