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)

Public API Change: Rename IFieldSymbol.AssociatedPropertyOrEvent , IMethodSymbol.AssociatedPropertyOrEvent and INamedTypeSymbol. AssociatedEvent APIs to AssociatedSymbol to accommodate for future language changes. (changeset 1210026)

1) GetHashCode had a misplaced parenthesis which made its algorithm deviate from the Fnv1a hash used elsewhere. Now it calls Hash.CombineFNVHash to be sure.
2) Split ToLower into a fast and slow piece to enable more inlining (Training data showed that it was, by far, the most frequently called method)
3) Enable short-circuiting of ToLower if chars are trivially equal
4) Fixed typos in comments (changeset 1209917)

I haven't quite determined _what_ is preventing the xsd from being read during a VS "Rebuild" operation, but let's avoid the whole mess by not copying the file to the output directory and loading it from disk at all. (changeset 1209457)

calculated indentation incorrectly for one of indent block option. (changeset 1209431)

* the code that was injecting indirect returns had unreliable logic when detecting the appropriate block.
We could end up injecting return in the middle of the method body and the rest would get dropped as unreachable.

* added debug visualization support for BasicBlock and ILBuilder.
We used to have visualization here shared with IL dumping, but it gradually migrated out to the test utilities.
It has been a while since we had to fix a bug in codegen, but now, I realize that it is fairly hard to debug this kind of issues without visualizers.
 (changeset 1209393)

 Change Description:

     This is the toolset changes to enable Open source developers to debug the results of their compiler hacking efforts.

     How it works:
     Unfortunately we can't do VSIX magic or binding redirect magic.  However, that leaves a pretty easy to understand solution.
     The Opensource developers will work in the defaultmain hive, their compiled product will be installed in the roslyndev hive.
     During the build we will overwrite the binaries in their deployed locations with the result of the build.
     They select CompilerPackage as their start package and press F5 this will build their product and deploy it to the start a new instance of Visual Studio using the Roslyndev hive and their new code.

     How to use it:
     There is a one time initialization prepare.bat, this must be run as an administrator, it creates the RoslynDev hive, Initializes and does sn - Vr on each Roslyn Assembly that the open source project builds

     to undo this, run prepare.bat with the u parameter.

     Once you have run prepare.bat set a global environment variable "OpenSourceDebug" to true just load up the roslyn solution and press F5, the build will put the right bits at the right place in the hive.  If the variable is not set then the normal build occurs and the RoslynHive will not be modified.

     There really isn't that much to it.

     Please Note I have hard coded the version # to 0.6.0.0 when building for OpenSourceDebug, builds otherwise the standard build applies.

     When the vbcscompiler has an app config based timeout switch, the build will replace the app.configs i n the package directories with equivalents from the open source build.
 (changeset 1209382)

1. Refactored AnalyzerDriver tests to reuse code for testing of the IDE diagnostic engine (DiagnosticAnalyzerDriver)
2. Added tests for DiagnosticAnalyzerDriver, verifying that all IDiagnosticAnalyzer family interface members are being called/accessed, AnalyzeNode/Symbol and OnCodeBlockStarted/Ended are called for a specific set of Symbol/Syntax/MethodKinds and all exceptions from user-implemented analyzers are caught (changeset 1209375)

How it works, the Workspace uses the ExecutingAssembly path to determine in which hive the package is running. It passes this as a Build Propert to msbuild.

Whenever the compiler package is loaded by vs it scans the bs/vwd/wd and vswinexpress directories to find all of the hives and writes out a when clause for each found hive.  The when clauses verify the existence of the roslyntoolpath directory before setting it.  The otherwise clause is the 12.0 hive for the app which has the directory.

 (changeset 1209363)

added global MyTemplate cache so that multiple compilations with same parsing option can share same MyTemplate rather than each parsing its own. (changeset 1209353)

If a workspace indicates that there are DocumentIds associated with a text container, then there should always be a current context DocumentId for that container. Therefore, when a document is opened in the Workspace, it should be set as the current context document for its text container if the 'isCurrentContext' flag is set or if there exists no current context document for that container. This change adds the latter condition and asserts if this state is out of sync when a feature attempts to get the active context document for a text container.

Additionally, the DocumentProvider check for whether a document key is in the current context is now correct in cases where multiple projects map to the same hierarchy. (changeset 1209326)

Modified C# directive parser to allow #pragma warning disable/restore to take string IDs in addition to integers in order to generalize to user-generated diagnostics. Compiler-generated diagnostics all have integer error codes in addition to a string ID, but user-generated diagnostics are only identified by a string ID. This change also affects the language grammar, effectively changing the grammar of "warning-list" in section 2.5.8.1 of the C# spec from:

warning-list:
    decimal-digits
    warning-list   whitespaceopt   ,   whitespaceopt   decimal-digits

to:

warning-id:
    decimal-digits
    string-literal

warning-list:
    warning-id
    warning-list   whitespaceopt   ,   whitespaceopt   warning-id

As implemented, the compiler will accept the following:

#pragma warning disable ?CS0168?
#pragma warning disable ?CS0168?, ?CS0219?
#pragma warning disable ?CS0168?, 219 // , ... etc.

And warn about the following:

#pragma warning disable ?CS168? // warning CS1691: 'CS168' is not a valid warning number
#pragma warning disable 1 // warning CS1691: ?1? is not a valid warning number (current behavior)

Only strings that match 'CS[0-9]*' are assumed to be compiler diagnostic IDs, so the compiler will not warn about something like:

#pragma warning disable "CS1MyWarning" // This could be a user diagnostic ID (changeset 1209083)

Make it possible to update CompilationOptions with new specific diagnostic options, rather than having to go through CSharpCompilationOptions or VisualBasicCompilationOptions to do this.

This is a public API change. (changeset 1208990)

PERF: Reduce SourceLocation allocations by avoiding the .Location property on SyntaxReference where possible. The .Location property was changed to a GetLocation() method to indicate that it carries a peformance cost.
This accounted for 3% of allocations in the C# typing perf test. The same change was made in VB for completeness, although the impact was much less in the VB typing scenario. (changeset 1208921)

Replaces FileResolver with 2 types that are portable and implement reference resolution for specific feature. The goal is to have 3 resolvers total - one for each kind of reference to artifact that the source may contain
1) MetadataReferenceResolver
Resolves #r directive values.
2) SourceReferenceResolver
Resolves source references and normalizes source paths. Used by #line, #pragma checksum and PDB paths (and #load in script files, which is not implemented yet).
3) XmlReferenceResolver
Resolves references to XML documents in <include> and PermissionSet(File = "...")

Each resolver is also a provider of the resolved content. Currently that's not true for MetadataReferenceResolver, we have a separate MetadataReferenceProvider. I'll follow up with a change that merges these two.

In addition to the above resolvers CompilationOptions still have AssemblyIdentityComparer and StrongNameProvider. These remain unchanged.

The non-portable part of the compiler provides a file resolver for each reference resolver:
1) MetadataFileReferenceResolver (to be renamed to MetadataFileResolver)
2) SourceFileResolver
3) XmlFileResolver

these resolvers implement csc/vbc behaviors.

Default CompilationOptions don't have any resolvers. Thus the features that are dependent on these resolvers won't work and a diagnostic is reported. (changeset 1208519)