This change does two actions to our public API files:

- Resets them to the versions from 1.0.0 RTM
- Splits them into the shipped and unshipped files

Changes include:

1. Enhance CompilationWithAnalyzers to allow computing analyzer diagnostics for a specific tree/span within a compilation and/or for a subset of analyzers. Implementation ensures no duplicate analysis by tracking partial analysis state and caching the reported analyzer diagnostics.

2. Overview of the new APIs added to CompilationWithAnalyzers:
    1. GetAnalyzerSyntaxDiagnostics(tree, analyzers, ct)
        1. Analogous to SyntaxTree.GetDiagnostics(ct)
        2. Gets analyzer diagnostics reported by executing syntax tree actions on the given tree.
    2. GetAnalyzerSemanticDiagnostics(semanticModel, spanOpt, analyzers, ct)
        1. Analogous to SemanticModel.GetDiagnostics(spanOpt, ct)
        2. Gets analyzer diagnostics reported by executing rest of the non-compilation actions on the given tree span.
    3. GetAnalyzerCompilationDiagnostics(analyzers, ct)
        1. Gets rest of the analyzer diagnostics which are reported by either of the following means:
            1. Compilation actions (and compilation end actions)
            2. Non-compilation actions reporting diagnostics on different tree: Executing a symbol action on a symbol definition in a tree, can report diagnostic on its partial definition in some other tree.

3. Simplify IDE analyzer driver by switching it to using the new CompilationWithAnalyzers APIs for analyzer diagnostic computation. Both the IDE and compiler drivers now use the compilation event queue model for driving analysis.

A large change again, mostly mechanical. There's a fair amount to clean up and that will come in the next commit.

This one is a much larger change but is mostly mechanical.

This change touches a lot of files but most of the changes are
mechanical. Essentially, this introduces a CompletionItemRules type as a
means to customize the behavior of a CompletionItem. This will
ultimately be the home of several methods that currently reside on
CompletionListProvider (such as IsCommitCharacter and
IsFilterCharacter), but only the SendEnterThroughToEditor method has
been moved in this change. Other methods will be moved in future
changes.

The targets files were previously split into an open version in
Microsoft.CodeAnalysis.Toolset.Open and a closed version in build/. This
unifies the four targets into two new targets, VSL.Settings.targets and
VSL.Imports.targets, and moves all the targets from ..Toolset.Open into
the build/ folder.

Currently, the C# and VB suggestion mode completion providers both implement ICompletionProvider
in nearly the same way. This change introduces a new base class containing the shared
implementations.

Note: prior to this change, C# and VB returned different values for IsCommitCharacter: false and
true respectively. Now they'll both return false. However, this is OK because the completion
controller handles builder completion items specially and IsCommitCharacter so that is never
actually called in this case.

There is a special completion list provider in VB for showing completions within Inherits or Implements
statements. This change removes that customer completion list provider and pushes its logic down into
the recommendation service. That way the Recommender API will correctly return these symbols, and the
symbol completion provider will service them up into the completion list.

Because the Implements/Inherits completion list provider produced an exclusive lists, a small tweak needs
to be made to the built-in type keyword recommender. Otherwise, keywords like 'Boolean' would be recommended
after Inherits, which isn't legal. Additionally, I've added a unit test to verify that 'Global' **does**
show up after Inherits and Implements.

Fix breakpoint handling and EnC of queries containing Select and GroupBy clauses that don't translate their select/group-by expression to lambda

The compiler does not generate semantic errors inside lambdas in the
presence of syntactic errors causing several features to not work in
lambdas with syntax errors.  The bug for this
([1867](https://github.com/dotnet/roslyn/issues/1867)) was moved to
milestone 1.1 so we are going to use an analyzer in the interim for 1.0.

1. We now check for IncompleteMemberSyntax nodes and
LambdaExpressionSyntax nodes which contain syntax diagnostics on any of
their descendant nodes.
2. We report both unbound identifier names and constructors that the
compiler reports as binding, but which fail overload resolution
(actually don't exist).

Performance considerations should be mitigated by only doing these
checks only lambdas with syntax errors.

Other notes:

- Renamed analyzer to UnboundIdentifier instead of AddImport since it is
being used in more places than just the AddImport fixer
- Updated the DiagnosticDescriptor for this analyzer to take
localizeable strings.

Fixes #1744
Fixes #1241
Fixes #1239

Upgrades System.Collections.Immutable to 1.1.34-rc and
System.Reflection.Metadata to 1.0.19-rc.

This reverts commit b37052d0.

When the DeclarePublicAPI analyzer was first put to use there were a couple of bugs in the compiler and IDE analyzer drivers for VB projects; this effectively limited the analyzer to C# projects. These have now been fixed, and it can be turned on for VB. (changeset 1411047)

1) Change MethdCompiler.BindMethodBody to associate correct syntax with BoundBlocks it creates when binding constructor with constructor initializer call (two bound blocks are created – outer one defines a closure scope for constructor parameters, the inner one defines a closure scope for variables in the body).
2) Introduce MethodDebugId – a method ordinal and generation ordinal pair
3) Introduce LamdbaDebugInfo and ClosureDebugInfo to represent information (syntax offset) we use to figure out how to map lambdas and closures to the previous generation.
4) Adds a new PDB CDI record (#7) to store lambda and closure debug info.
5) Generalizes CalculateLocalSyntaxOffset to handle positions in field/property initializers and constructor initializers. Use it to calculate syntax offsets of lambdas and closure scopes. (TODO: rename CalculateLocalSyntaxOffset to CalculateSyntaxOffset).
6) Replace lambda and scope ordinal dispenser integers with array builders that collect LambdaDebugInfo and ClosureDebugInfo.
7) Use TryGet- pattern for all VariableSlotAllocator APIs.
8) Implements mapping of lambda method and display class names to previous generation via VariableSlotAllocator.
 (changeset 1407240)