Lazily evaluate the root node for syntax trees

[chsienki]

This avoids an issue where we continually recover syntax trees in the IDE, even when they havn't changed, which has a noticeable perf impact.

[chsienki]

@dotnet/roslyn-compiler for review please.

[sharwell]

❔ Can we not make this accept SyntaxTree instead? The call to GetRoot is cheap at the point where it's required.

[chsienki]

Is it cheap to call it multiple times? If you have multiple generators, each one will call tree.GetRoot() I didn't want to asssume that subsequent calls would be cheaper...

[sharwell]

It's unlikely for the call to GetRoot to be expensive for the second and subsequent calls (when needed). There is a brief moment where the root could be collected by the GC when moving from one source generator to the next. It could be prevented like this:

Suggested change

	void VisitTree(Lazy<SyntaxNode> root, EntryState state, SemanticModel? model, CancellationToken cancellationToken);
	void VisitTree(SyntaxTree tree, ref SyntaxNode? lazyRoot, EntryState state, SemanticModel? model, CancellationToken cancellationToken);

Then where you need the tree:

var root = LazyInitialization.EnsureInitialized(
    ref lazyRoot,
    static arg => arg.tree.GetRoot(arg.cancellationToken),
    (tree, cancellationToken));

[chsienki]

Hmm, Jared pointed out that if we only get the root when the tree is different, then it's unlikely to be a recoverable tree in the first place, in which case GetRoot should be cheap. @sharwell does that seem correct?

[sharwell]

I'm not sure why that would make a difference. It should be cheap, even if recoverable, but either way you can eliminate the use of Lazy<T> with the pattern I gave.

[chsienki]

@dotnet/roslyn-compiler for a second review please :)

[chsienki]

Rebasing to main for merge.