Tie query nodes to their parent

Categorize synthesized query lambdas
Make sure SynthesizedLambdaSymbol and BoundQeuryLambda has the same syntax

Enable editing VB methods containing lambdas and queries, except for methods containing Aggregate, Join and Group By clauses

Add GetLambda helper method to avoid implicit dependency on the fact that lambda body parent has to be a lambda node

Fix a NRE in VB query expression binding

Fixes #1099

There were uses of private fields in #if blocks that needed to be
adjusted to the renamed fields.

Detect and report attempt to use abstract event through base

Introduce a new AbstractEncProject for CSharpProject and VisualBasicProject to extend.

Enable editing methods with anonymous types and remove unused rude edit kinds

This fixes up the misaligned comments that came from the formatting bug
described in #1177.

closes #1140

This is the initial run of the code formatter on the VB compiler source code.  Further runs I'll expand on this to include all VB code in a future run.

New EvaluationContext cache-invalidation strategy

Cleaned up C++ project targets

Ignoring references, which are obviously the high-order bit, the old
strategy was to confirm that the methodToken, methodVersion, and smallest
containing scope were the same as the current context.  This had two
problems:

1) C# hoisted locals are not reflected in scopes and so we were not
invalidating the cache when we stepped across scope boundaries in async
and iterator methods.

2) We had to access the PDB in order to check whether the cache was still
valid (to figure out the smallest containing scope).

We propose a new approach: compute the largest span around the current IL
offset in which there are no scope boundaries (including hoisted local
scopes).  Then, when check cache validity by doing a simple span
containment check (plus methodToken and methodVersion, obviously).

Downside 1: We need all scopes in the method, not just the containing
ones.

Downside 2: If you somehow step around a nested scope (e.g. using
breakpoints), the new approach will invalidate the cache, whereas the old
one did not.

Check SyntaxNodeOrToken is a SyntaxNode before converting

This project does the appropriate Enc hookup, and implements the interfaces that the debugger
QIs for to do Enc interaction.

For C# and VB, nothing will change.  For TypeScript, we will continue subclassing AbstractProject.
By doing this, we will not interact with the Enc system at all.  This will help avoid undesirable
behavior (like having our files become read-only when entering debugging).

Fix Extract Method and Generate Variables in Conditional Access Expressions.

Fixes #751.

Properly handle ConditionalAccessExpressions in ExpressionSyntaxExtensions::CanReplaceWithLValue. When conditional access expressions begin with some form of member binding expression (starts with the dot operator), they cannot be replaced with an LValue. @jmarolf contributed commit cf3dd545

This issue does not affect VB as VB language parses this differently than C#.

Fix internal TFS bug 1130555 : Getting Parent of SyntaxNodeOrToken
does not need conversion to Node or Token.

When converting a SyntaxNodeOrToken to a Node or Token use IsNode or IsToken.

In this particular instance, we have introduced the check in
InlIneTemporaryCodeRefactoringProvider to prevent crash. We will still
have to find the scenario that triggered this situation.

Fix a build break by adding a parameter to an otherwise parameterless struct ctor

Implement EnC support for range variables in C# queries, improve query clause matching

don't handle code link ourselves but let error list handle it

Catch exceptions from user code

Add the `GetDiagnosticDescriptors(DiagnosticAnalyzer)` method to the
`IDiagnosticAnalyzerService` interface.

Don't swallow OperationCanceledException fired with our cancellelationToken. These are supposed to be handled up the stack and swallowing them would mean unnecessary computation would be done for result that would eventually be ignored.

Don't swallow OperationCanceledException fired with our cancellelationToken. These are supposed to be handled up the stack and swallowing them would mean unnecessary computation would be done for result that would eventually be ignored.