Add support for accessors and WriteOnly to SyntaxGenerator

Move serialization specific BitArray helpers to where they are used

fix resource string that was causing an invalid xml doc comment to be generated

Make locals case-insensitive in the VB EE

fix a case where we subscribe to an event while global operation is alre...

update unit tests to use localized resources

1) Pass StringComparer.OrdinalIgnoreCase to the dictionary of (real)
locals.
2) Canonicalize (i.e. lowercase) the names of pseudo-variables and
locals declared in the Immediate window (because the debugger APIs
we call are case-sensitive).

one of test found a case where we subscribe to an event while global operation is running. and we crash when stop event is fired.

DkmClrValue.GetMemberValue also needs a DkmInspectionContext parameter...

EE: Bind to intrinsic methods from assembly supplied by the debugger

These files are a hold over from when Roslyn was in TFS.  They aren't
needed anymore now that we are in git.

closes #858

Fix for #271: Compiler crashes if it cannot locate resources for analyzer

CLR calls us back to search for presence of satellite resource assembly with ".resources" suffix, before attempting to go back to the main assembly as a fallback for resources. However, during this callback we were trying to load the satellite assembly without checking if the file exists on disk, causing an unhandled FileIOException.

Adding the NeutralResourcesLanguageAttribute in PR #831 caused the CLR to directly go to the Main assembly for resources, without making the satellite assembly callback.

I removed this attribute locally from our analyzer assemblies, and with the added File.Exists check, we correctly return null for satellite assembly callbacks and CLR eventually falls back to the Main assembly for resources and we are able to find resources.

Re-enable AsyncLazy tests by rewriting them and improving AsyncLazy's behavior in one or two places.

Move our extra solution to work with CTP6

Filed issue #860 to cover tracking down these failures.

This change moves Roslyn2013.sln to work with Visual Studio 2015 CTP6.
This allows customers, and Jenkins, to build and test significantly more
code than was available with the old solution.

This is still not as full Roslyn.sln because not everything is buildable
against CTP6.  In particular our Visual Studio components and all of
their dependencies can't build due to API changes we depend on that came
into being after CTP6.  It is much closer though than our previous
solution.

As a part of this change I also renamed Roslyn2013.sln to
RoslynLight.sln.  The 2013 moniker was no longer valid and lacking a
better word I chose light (it has less projects and hence is lighter).

When a request to AsyncLazy gets a cancellation, we asynchronously
cancel the underlying Task, since any continuations might run inline
and cause surprises. This meant that if cancellation happened during
a call to GetValueAsync or GetValue where the underlying computation
was synchronously completed, there was a race where the task that
gets returned might or might not be cancelled. It didn't strictly
matter -- since cancellation is best-effort it was fine by the contract.
But to test an earlier bug, we forced it into the non-cancelling
case by simply stopping up the thread pool so the asynchronous
cancellation never happened. That approach was really evil, so we try
something else.

Now, we adjust the tests to assert the slightly stronger statement that
once a computation runs and returns a value, it's cached, even if
the value is not handed out. (The implementation already did this,
but we now assert it.) We also tweak the cancellation handling to
cancel the returned task more aggressively. This avoids the race
between async cancellation and synchronous value returning in the
context of the unit test, so we can assert behavior better. In general
there's no guarantee, but it's now guaranteed "enough" our test can
test the other behaviors well.

make sure we cancel outside of enumeration

Add explicit null checks during module lookup

Improve exception filter parsing error recovery

When we originally introduced exception filters to C#, we used the if
keyword in the filter clause.  To avoid confusion with regular if
statements, we switched to using the when (contextual) keyword.

Unfortunately, the if syntax was around long enough that code with that
syntax was stored in the source server database.  Now, when you try to
debug such files, they parse very badly.  In particular, there is a file
in the debugger in which thousands of lines of text become skipped text
trivia and the resulting syntax tree results in an
InsufficientExcecutionStackException whenever that file is displayed.
This makes it very difficult to inspect older dumps.

A simple solution is to allow the if keyword and replace it with a when
keyword with an error attached.

With this change applied, the debugger crash is resolved.

We got a release-build dump with a NRE in a location that didn't make sense.  Based on our best guess of what happened (something that should be impossible) add some explicit checks so that we'll get a clearer stack trace if it happens again.

No tests since we still believe this is impossible.

Disabling test:  ConditionalMemberAccessRace002

Failing due to #836