Parsing of spread element expressions
Initial entrypoint in SourceFile for the LS to call to peform incremental parsing.

Right now the entrypoint just causes a full parse to happen.  But the LS code is
cleaned up to take advantage of it appropriately.
Update comment.
Merge branch 'master' into sourceFileUpdate

Conflicts:
	src/services/services.ts
	tests/cases/unittests/incrementalParser.ts
Don't call into the incremental parser for now.

Return a tree if the textChangeRange is empty.
Move TextSpan into the compiler layer.
Move textSpan and textChangeRange impls to the compiler layer.
When updating the text for a source file, extrend the changed range.

This ensures that nodes/tokens affected by lookahead will be reparsed.
Sweep and mark nodes before going and performing incremental parsing.
Initial stubs for the incremental parser logic.
Rename method.
Understand and handle modifiers on function declarations and variable statements within blocks.

This ensures reusability for functions/variables that may have been outside a block, but end up
inside one afterwards.  It also ensure the same tree is produced when incremental parsing.

i.e.  if you have:

declare function F() { }

And you add a { above it, then we current have an incremental parsing bug.  Namely we would see
a FunctionDeclaration node and say 'yes, we can reuse that node while parsing the block'.  This
is currently broken because the normal parse would not have normally accepted such a node (because
of the modifiers).

This was an example of contextual parsing of the same kind of node.  Something which we do not
want to do if we want incremental parsing to work properly.
Incremental parser tests should verify the same set of diagnostics are produced.
More incremental parser tests.
Support modifiers on index signatures in an object type.

This makes index signature parsing non-contextual.  This is necessary so that
incremental parsing can reuse index signatures acros classes and object types.
Support modifiers on object literal methods and accessors, and question tokens on object literal methods.

This makes parsing of these constructs the same whether they are in an object literal or a class.

This is important for incrementla parsing for knowing if we can reuse these nodes if we run
into them.
Add additional incremental tests.
Unify accessor declaration parsing.
Remove TryBlock and FinallyBlock.

They break the rule that syntactically identical constructs use the same syntax kind.  This
prevents node reuse in incremental parsing.
Merge branch 'master' into funcDeclsInBlocks