1. Look for declarations in the current submission (including aliases).
 2. Look for declarations in preceding submissions (including aliases), in
 order.
 3. Look for members in the host object (if any).
 4. Look for declarations in the global namespace.
 5. Look in usings (except aliases) in the current submission and all
 preceding submissions (all at once, not looping).
 6. Look in the global imports of the current submission and all preceding
 submissions (all at once, not looping).

Note that 5, 6, and aliases from 1 are skipped if we are binding the
target of a using in the current submission.

Fixes #5450
Fixes #4811

Look at the usings for each submission as we visit that submission.  The
mental model is a chain of ```InContainerBinder```s, but we don't actually
instantiate the chain for perf reasons.

TODO: Some tests are failing because of the new semantics.  The main issue
is that usings can now hide members (not just types).  No corresponding
issue exists in C# because usings can't appear within types.

When emitting a lambda method that binds to a delegate with dynamic
parameters, emit the dynamic attribute in the corresponding parameter
locations. This facilitates debugging of the lambda as parameters will
properly light up as dynamic in expression evaluation.

close #4160

Fixes #5450
Lays groundwork for #4811 and #5423

Add a new CompilationOption "ReportSuppressedDiagnostics" to enable reporting compiler diagnostics suppressed in source. Note that the command line compilers will report such suppressed diagnostics in the SARIF errorlog file but not on the console output.

This new compilation option was approved by the design team.

Fixes #5216

Emit "isSuppressedInSource" boolean property for diagnostics in the ErrorLog file and report suppressed analyzer diagnostics in the error log.

1. CompilationWithAnalyzers can now report analyzer diagnostics with source suppressions (pragma/SuppressMessageAttribute). This will eventually allow us to surface diagnostics with source suppressions in the error list. Note that the behavior of command line compilers and all the GetDiagnostics APIs is unchanged, only the compiler analyzer will report diagnostics with source suppressions.

2. Add FixAll support for Suppression code fixes. Light bulb suppression fixes now show the "Fix all occurrences" options for Document/Project/Solution. This change adds the basic functionality to bulk suppress diagnostics. This will eventually be consumed for baselining all/selected diagnostics from error list/solution explorer.

3. Simplify the Suppression light bulb menu to remove the option to add a local SuppressMessageAttribute. The only options now are to suppress in source (pragma) or suppressions file (assembly level SuppressMessageAttribute).

Fixes #4924.

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.

...as AddSyntaxTrees does.

The errors being reported in the declaration table were inherently
syntactic and moving them into the parser eliminates some complexity.

Note: VB is not currently reporting
ERR_ReferenceDirectiveOnlyAllowedInScripts since it does not (yet)
lex/parse reference directives.

As an optimization, submissions not containing declarations are not
emitted.  However, when we short-circuit emission, we also skip diagnostic
reporting (e.g. in usings) that can trigger an assert in the next
submission (which assumes that all errors have been reported).

Fixes #3795

This reverts commit 15443a23.

Conflicts:
	src/Compilers/CSharp/Portable/CommandLine/CommandLineParser.cs
	src/Compilers/CSharp/Portable/PublicAPI.txt
	src/Compilers/Core/Portable/PublicAPI.txt
	src/Compilers/VisualBasic/Portable/CommandLine/CommandLineParser.vb

Fixes #2888
Fixes #3786

Add DiagnosticDescriptor.GetEffectiveSeverity(CompilationOptions) API to get the effective severity of diagnostics created based on the descriptor for the given compilation options.

This change also removes the clone of this functionality in the IDE layer used by the solution explorer rule severity display and error list/diagnostic service. It now uses this public API.

Fixes #2598

In some scenarios, an attribute application can be “bad” due to an error type in referenced compilation, but without any diagnostics reported for the referencing compilation.

Enable hosts to compile strong-named assemblies on all platforms by supplying public key via compilation options and also enable OSS signing with such key

Related to #846.

Calling GetSemanticModel with suppressAccessChecks=true creates a SemanticModel that ignores accessibility rules when answering semantic questions.
This allows consumers to ask semantic questions using the same semantic rules as the ones used in debugger’s Expression Evaluator, where accessibility rules do not matter.

Added unit tests for C# and VB.NET to cover both regular and speculative analysis.

It ensures the following for the lifetime of analyzer host:
1) DiagnosticAnalyzer.Initialize(AnalysisContext) is invoked only once per-analyzer.
2) DiagnosticAnalyzer.SupportedDiagnostics is invoked only once per-analyzer.
3) CompilationStartAnalyzerActions registered during Initialize are invoked only once per-analyzer per-compilation.