Ensure custom modifiers are copied for types of overriding properties and events even in the case of dynamic/object mismatch.

Fixes #7674.

Fixes #4696.

Pay attention to sizes and lower bounds specified for multi-dimensional arrays in metadata signatures.

Fixes #4954.

We will treat Sizes and LowerBounds similar to custom modifiers. They should match for the purpose
of signature comparison (overriding/implementing, etc), but shouldn't affect conversions.

Related to #846.

     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)

Marks CSharpKind and VBKind extension methods as Obsolete and adds equivalent extension methods Kind for both languages.
Marks CSharpKind and VBKind instance methods on language specific syntax nodes Obsolete as well.
 (changeset 1389494)

Marks CSharpKind and VBKind extension methods as Obsolete and adds equivalent extension methods Kind for both languages.
Marks CSharpKind and VBKind instance methods on language specific syntax nodes Obsolete as well. (changeset 1388816)

This brings us back on par with Dev12.
***NO_CI***
 (changeset 1385660)

***NO_CI***
 (changeset 1356181)

For accesses to an autoprop in a corresponding [static|instance] constructor -

(a) It should bind to the property, but the property should be treated as a readable/writable even if it is a readonly autoprop.
(b) The definite assignment behavior should be as if directly accessing the backing field.
(c) It should code gen to the property accessor (if one exists) or a field access (if not).

The most observable outcome of all this is that it is possible to assign a readonly autoprop in the constructor and that
in a struct instance constructor you no longer need to initialize whole struct before using any of its autoprops.

The following code is now valid and does what you think it does:

public struct S
{
    public int X{get;}
    public int Y{get;}

    public S()
    {
        X = 42;
        Y = X;
    }

    public static void Main()
    {
        S s = new S();
        System.Console.WriteLine(s.Y);
    }
}

.

 (changeset 1346315)

Fix bug 1032724: Do not give error CS0842: 'C.X': Automatically implemented properties cannot be used inside a type marked with StructLayout(LayoutKind.Explicit) for static auto-properties (changeset 1345941)

Ensure that a property with an initializer has a backing field symbol, SemanticModel needs it to bind the initializer. (changeset 1317711)

An expression body is an alternative to a block on certain members (properties, methods, operators, and conversions), which uses the lambda => to define an expression as the body of the member. (changeset 1281748)

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)

An expression-bodied property is a property with an expression instead of accessors, i.e. syntax st. a property P written as

... type P { get { return e; } }

is equivalent to

... type P => e;

This feature is experimental and keyed on the Experimental LanguageVersion. (changeset 1263330)

Features the new syntax ('= expr;'), new rules around required accessors, and allows auto property and field initializers in structs. (changeset 1251890)

In C# lowering of async method stored the state machine type on SourceMethodSymbol so it can later be used when emitting synthesized attributes of the method. This may cause issues when emitting the same compilation twice with different options that affect the state machine type.
     Instead we should store the state machine type to the current PEModuleBuilder. Rather then actually storing it there and adding a dependency on PEModuleBuilder to the attribute generation this change introduces ModuleCompilationState (similar to TypeCompilationState) and threads that one.
     This type is designed to be mutable during compilation (lowering) and immutable during emit. The idea is that all data currently stored in PEModuleBuilder that are produced during compilation and only read in emit could be moved there. Only emit specific data would remain on PEModuleBuilder.

     Also refactors Compilation.Compile to remove some duplication and make it cleaner.
 (changeset 1249664)

so that you are likely to only see events from within the span of interest. (changeset 1217425)