previously, it was a bit more complex than needed. I cleaned/simplified it a bit. (changeset 1213970)

Expose AnalyzerReferences instead of the actual Analyzers at workspace layer: After taking feedback from Matt and Neal, we have decided to expose the analyzer reference assemblies from the workspace, instead of the actual diagnostic analyzers. This change adds the following public types (analogous to MetadataReference hierarchy) and changes the workspace APIs to work with the base AnalyzerReference type:
1) AnalyzerReference: Base type representing all analyzer references.
2) AnalyzerFileReference: Analyzer reference based on actual assembly file on disk. Analyzers are loaded lazily and weakly cached.
3) AnalyzerImageReference: In-memory or pseudo analyzer reference which is just a wrapper over an array of analyzers. This should enable clients to add custom analyzers directly to a project, without requiring a file reference.
4) UnresolvedAnalyzerReference: Internal type for unresolved analyzer references on command line. (changeset 1213934)

 (changeset 1213897)

 The Type PersistentStorageOptions and WeakAction has been changed from Public to Internal since we dont want to expose these types to the Public. (changeset 1213888)

     Some of the GFU related types that were introduced in the feature layer has been Public. Since we are releasing this to public, unrelated types which are public will be changed to Internal with this change. (changeset 1213874)

They're used in just one place each - in the various "DescendantNodes" routines.
The allocations for these unions are wasteful because the size of the combined structure is the sum of the sizes each part plus one for a "discriminator" byte.

The allocations were showing up as ~1.5% of the C# goldilocks typing scenario.
This change replaces the "Stack of Union" with a "UnionStack". The Union stack is actually multiple stacks in one - one for each type and a disciminator "master" stack.
We can also make use of object pooling to further reduce allocations. (changeset 1213710)

MetadataHelpers.SplitQualifiedName interllay uses string.Split. This results in an allocation. The allocation is immediately converted to an ImmutableArray.

This change replaces string.Split with a hand-rolled algorithm that tries to avoid allocations. First, zero or 1 length arrays avoid any intermediate allocations.
For larger results, the exact length is precomputed and we try to get an ArrayBuilder from the pool.
As a bonus, since "System" is such a frequent first string, we avoid a new substring allocation. (changeset 1213621)

Couple more places where boxing can be avoided (changeset 1211849)

 (changeset 1211723)

DiagnosticDescriptor API changes and documentation comments: Change the DiagnosticDescriptor API as per the Diagnostics API review feedback. It now has following field with corresponding doc comments:

        /// <summary>
        /// Create a DiagnosticDescriptor, which provides description about a <see cref="Diagnostic"/>.
        /// </summary>
        /// <param name="id">A unique identifier for the diagnostic. For example, code analysis diagnostic ID "CA1001".</param>
        /// <param name="description">A short localizable description of the diagnostic. For example, for CA1001: "Types that own disposable fields should be disposable".</param>
        /// <param name="messageFormat">A localizable format message string, which can be passed as the first argument to <see cref="M:System.String.Format"/> when creating the diagnostic message with this descriptor.
        /// For example, for CA1001: "Implement IDisposable on '{0}' because it creates members of the following IDisposable types: '{1}'."</param>
        /// <param name="category">The category of the diagnostic (like Design, Naming etc.). For example, for CA1001: "Microsoft.Design".</param>
        /// <param name="defaultSeverity">Default severity of the diagnostic.</param>
        public DiagnosticDescriptor(string id, string description, string messageFormat, string category, DiagnosticSeverity defaultSeverity) (changeset 1211580)

Rollback 1211545.  Turns out the vsix tools are unhappy with non-vsix projects that try to deploy themselves. (changeset 1211572)

When MSBuildWorkspace is reading .csproj/.vbproj files, it now doesn't crash if the <Project> metadata item (GUID) on a <ProjectReference> item is not set (there are some project references out there that don't specify a GUID). Since VS allows such project references, we should too.

Also, if <ReferenceOutputAssembly> is set to false, we will now just skip the reference. Earlier we were ignoring this metadata and always adding a reference. (changeset 1211532)

It seems that it doesn't support wp8 anymore. (changeset 1211501)

Update System.Reflection.Metadata 1.0.8 -> 1.0.9 (changeset 1211431)

Adjusts sequence points of array-initialized local variable declarations to match field declarations.

     Before -> after
     Dim [|F(1), G(1) As Integer|]  ->  Dim [|F(1)|], [|G(1)|] As Integer
 (changeset 1211413)

Remove use of obsolete type Xunit.Sdk.TraceAssertException added by my previous checkin. (changeset 1211338)

Ensure that when building roslyn we delete tthe vssqmmulti.dll (sqm logging) so that OSS builds do not provide innacurate logging. (changeset 1211284)

With the change, the AnalyzerDriver can now be passed a flag called "ContinueOnError"

When FALSE - AnalyzerDriver will not handle the exceptions thrown by the Analyzers and the exceptions will be escalated as a Fail-fast Mechanism

TRUE - The exception thrown by the analyzer is also recorded as another Diagnostic and the AnalyzerDriver continues with the rest of the Analysis (changeset 1211244)

User story 900556 (Workspace support for analyzers\rulesets): Add Workspace APIs for Per-Project DiagnosticAnalyzers:
1) Property to get analyzers: Analyzers
2) Methods to update analyzers: AddAnalyzer(s), RemoveAnalyzer, WithAnalyzers
Also updated the IDE diagnostic service to now work for per-project analyzers.

Tests: I have added a test for new workspace APIs. I am working on adding tests for the diagnostic service per-project analyzer support, using the added workspace APIs for populating per-project analyzers. (changeset 1211161)

The cause is that in CanReplaceWithLValue(), direct parent kind checking is missing the cases of CollectionInitializerExpression and ArrayInitializerExpression.

The fix is to add the missing cases.  This change also adds cases of InferredFieldInitializerExpression, YieldStatement, and WhileStatement to the VB counterpart. (changeset 1211102)

We were throwing unreachable when we fell out the bottom of some complicated error handling code and Tomas hit it while dogfooding.  We were unable to determine the path that resulted in the crash, but there were enough problems that a more comprehensive cleanup seemed desirable.  The catch-all diagnostic is now checked last and actually serves as a catch-all.

Miscellaneous improvements:
1) Eliminated MemberCouldTakeArgumentCount which was trying to approximate overload resolution.
2) Standardized mechanism for iterating of list of candidates.
3) Eliminated MemberResolutionKind.BadGenericArity.  Comments explicitly stated that it was never used.

CR: AlekseyT (changeset 1211059)

     Fixes various issues around fields with shared initializers (e.g. Dim a,b As New C()) and auto-properties with AsNew clause (e.g. Property P As New C()).

     Makes breakpoint spans (IDE) consistent with sequence points (compiler) and makes sequence points for various forms of field and property initializers also more consistent with each other.
     Specifically:

     before:                                                                                  after:
     <A>Dim [|F As Integer = 1|]                                              <A>Dim [|F As Integer = 1|]                                         (no change)
     [|<A>Property P As Integer = 1 Implements I.P|]           <A>Property [|P As Integer = 1|] Implements I.P     (changed to match fields)

     Dim [|F|], [|G|] As Integer = 1                                              Dim [|F|], [|G|] As Integer = 1                                       (no change)
     Dim [|F(1), G(1) As Integer|]                                                Dim [|F(1)|], [|G(1)|] As Integer                                    (change to match fields with shared AsNew clause)
 (changeset 1210991)

This change adds a new interface, IAnalyzerHost, implemented by the C# and VB project system shims.

A future change will update vbproj.dll and csproj.dll to call the methods in this interface to inform us of <Analyzer> and <RuleSet> items in project files.

There are a few missing pieces of functionality that will be filled in later:

1.) We end up loading the analyzer assemblies on the UI thread as soon as AddAnalyzerAssembly is called. This may cause undesirable pauses while loading a project or changing settings. Ideally we would just pass in information about the analyzers and the workspace layer would handle the actual assembly loading.

2.) We don't yet hook up file change listeners for the ruleset files. Ideally we would hook up a listener to the ruleset file and the transitive set of other ruleset files it includes, and reload the rules whenever one of them changes on disk.

3.) The information about analyzers is not currently being passed from the host to the workspace. (changeset 1210973)

The open source build has CompilerPackage project and CompilerPackageFiles project both of which generate CompilerPackage.dll.  This check in fixes that by renaming CompilerPackages dll to CompilerPackageVSIX.dll

Make a similar change to:
    VSWindowsDiagnostice, CSharpRepl and VBRepl (changeset 1210613)

This changes removes the ProjectDependencyService and replaces the Solution's itnernal transitive dependency tracking with the ProjectDependencyGraph.  After the change removing async projects from solutions, the service was no longer necessary, as dependency graphs (mostly on demand) can be computed and reused for most solution branching.  The solution's internal transitive dependency tracking then became redundant. (changeset 1210210)