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 1408227)

Add an instance public Kind() method on CSharpSyntaxNode and VisualBasicSyntaxNode as a replacement for obsoleted CSharpKind(), VBKind(). (changeset 1389507)

- Update the parser to produce such nodes when parsing assignment expressions
- Port the rest of the compiler and related tests over to AssignmentExpressions
- Port the workspace layer, its tests, and the samples over to AssignmentExpressions.
- Port the editor features, samples, VS support, and related tests over to AssignmentExpressions. (changeset 1338828)

Added virtual members to Binder to reduce dependencies on containing type/member when binding "this" and "base"
(new members: ThisType, IsScriptClass, and IsInstanceMemberContext) and changed LookupSymbolsInSingleBinder from protected to internal. (changeset 1306929)

To support EnC well the compiler needs to carefully distinguish between long-lived and short-lived synthesized variables. Long-lived variables may cross sequence points and thus need to be mapped the the corresponding variables in the previous generation when emitting EnC deltas. Short-lived local variables shall never cross sequence points.

This change revisits helpers that create synthesized variables and assigns each synthesized variable a SynthesizedLocalKind. Negative kind values are reserved for short-lived variables, positive values for long-lived variables.

The change removed the option to give a synthesized variable an explicit name. The names of the variables are assigned at code-gen time based on their SynthesizedLocalKind. This is to enforce that the names of long-lived variables follow a naming pattern that allows use to reverse-engineer the SynthesizedLocalKind value from the variable name.

Also renames DebugInformationKind.PDBOnly to DebugInformationKind.PdbOnly to follow .NET naming guidelines.
 (changeset 1293017)

Splits Microsoft.CodeAnalysis, Microsoft.CodeAnalysis.CSharp and Microsoft.CodeAnalysis.VisualBasic into portable and desktop assemblies.

Existing Core\Source, CSharp\Source and VisualBasic\Source directories are renamed to Core\Portable, CSharp\Portable and VisualBasic\Portable.
New sibling Desktop folders are added and non-portable source is moved there.
"System.Runtime" references has to be removed in order for the portable project system magic to automatically add facade references.
 (changeset 1281686)

More:
- Skip checked/unchecked expressions (similar to parenthesized) when we are trying to determine if Declaration Expression is used as an argument.
- Fixes/unit-tests for SemanticModel APIs when Declaration Expressions are used inside an “expression bodied” property.  (changeset 1273421)

Ensure each lambda, including an implicit lambda in a query expression, has its own scope for declaration expressions within it. Fixes https://roslyn.codeplex.com/workitem/2. This is a port of https://roslyn.codeplex.com/SourceControl/changeset/e79e272450264fb41a2f7f39b3fbaf3a0e73021b. (changeset 1250867)

Migrated state of “Declaration Expressions” implementation equivalent to https://roslyn.codeplex.com/SourceControl/changeset/b7fd08a5695e21cd4d23b8b70815c53656dab65f. (changeset 1249879)

The updated rules will be described in detail in the spec.

     What they mean essentially is:
     ? Only local/parameter/query variable _declarations_ can clash. Other uses of names do not introduce anything into local scopes.
     ? Shadowing of local/parameter/query variables from outer scopes is illegal.

=== Examples:

1)
        class C
        {
            void Foo()
            {
                Bar();
                { int Bar; }        // name was used in the outer scope - Ok now
            }
            void Bar() { }
        }

2)
        class C
        {
            void Foo(int Bar)
            {
                int Bar;            // redeclaration of a parameter ? NOT Ok
                { int Bar; }        // redeclaration of a local ? NOT Ok

                // 2 redeclarations of a local ? both NOT Ok
                try { } catch (Exception Bar) { int Bar; }

                for (int i = 0; i < 10; i++)
                {
                    int i;          // redeclaration of a local ? NOT Ok
                }
            }

            void Bar() { }
        }

 (changeset 1231594)