* fixed a race where solution cralwer used wrong solution for it to process.

race is this.

1. solution crawler picked up a solution
2. before processing the solution, workitem got changed
3. and then picked up an work item from the queue
4. and use the work item with the solution that got picked up in step 1

step 2 is happening beacuse solution has changed, but step 4 used old solution from step 1
that doesn't have effects of the solution changes.

solution crawler must pick up solution after it has picked up work item from the queue so that new changes of a solution get enqueued as new work item,

* Update src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.NormalPriorityProcessor.cs

thank you
Co-Authored-By: Nheejaechang <hechang@microsoft.com>

* addressing feedback

The previous implementation assumed that it'd get a call from the
old DocumentProvider to know when new files were opened so it could
add it to the list of frames. When I deleted the DocumentProvider, that
hookup wasn't working anymore, and so it would never be tracking
anything at all. Oops.

Rather than couple some types together, the implementation is now
more standalone. I've elected, rather than also listening to RDT events
to simply start tracking a frame the first time it's activated.
The only way I can think a document could be made visible without being
activated that we would care about is on first time load when we
re-open existing documents. If you had a bunch of documents open, and
they were in different frames/windows, we won't consider the non-active
documents to be visible until you first focus on them. I'm not sure this
is really much of a loss; we've often seen that many customers have
files reopened on them that they didn't care about, so this might
actually improve solution open performance since we won't be processing
files they may not care about.

This also brings the service up to a slightly more modern/correct
implementation. This is now a proper MEF part that doesn't assume it's
being created on the UI thread, and it manages it's own shutdown rather
than assuming the package will shut it down in the package unload.
The previous implementation also was a bit strange in that it was a
workspace service, but still had a singleton underlying the whole thing.
The singleton was broken in that different files might be in different
workspaces, but it would always give DocumentIds out for all of the
workspaces, despite it being documented as "only returns for the given
workspace". There's still a singleton doing all the Visual Studio
eventing, but there's now per-workspace logic to correctly filter it.

Unlike the previous implementation, this doesn't really do any cleanup
anymore other than ensure that the async tasks started are joined to
avoid things running after MEF shutdown. Practically, us unsubcribing
events brought no value to anything other than spending extra time
during shutdown, so we'll just leave that as is. It feels "wrong" but
it's the way many are arguing this should be done these days.

Lastly, this now uses async service provider to fetch services. Calls
for data do not block on the service provider having done that work,
since doing so would violate other parts of Roslyn assuming that we
wouldn't block on the UI. I think it's fine, since this service is
very much a tool for optimization only. It still uses JTF internally
on calls that we know are coming in from VS (namely, the .Dispose()) so
that's fine.

This reverts commit 166349c8.

output paths are not specifically affecting semantics of code but some analyzer such as source based test discovery requires it to generate correct data. so they want to be re-analyzed when those are changed as well.

since output path are rarely get changed. decide to add it as one of cause to reanalyze projects.

Fixes #30886: Bail oun special serialization constructors and methods with certain special attributes indicating special usage.

Fixes #30887: Bail out on ShouldSerializeXXX and ResetXXX pattern that was also excluded from legacy FxCop implementation and seems to be common in real world code.

Fixes #30377 : Bail out on methods with signature matching event handlers, which are very common in Web apps.

Fixes #30894

Fixes #30965

Fixes #30895

This analyzer does not function correctly in presence of VB handles clause due to IOperation bugs #30978 and #30979. This change adds a temporary workaround to the analyzer to handle this case specially.

TODO: File a bug to track reverting the temporary workaround once #30978 and #30979 are fixed.