Improve performance when fetching Decls.

[rolfbjarne]

The current implementation in clangsharp_Cursor_getDecl to get a Decl is an N^2 algorithm; getting a Decl for index X means looping through all the previous indices 0-(X-1) first.

This is rather slow when dealing with hundreds of thousands of Decl instances, here's a screenshot from Instruments showing 74% of the time spent in clangsharp_Cursor_getDecl:

So I added a way in LazyList to use an existing item to get the next item, and then use Decl.NextDeclInContext to take advantage of this, effectively making an N algorithm (which becomes 2N, because we iterate over all the Decls first to count them).

My main scenario now runs in ~51 seconds instead of 3m05 seconds, so less that 1/3 of the time.

[tannergooding]

Storing the C++ iterator in C# to keep iterating on it is beyond my C++ knowledge (in particular any iterator lifetime management didn't look trivial).

In this particular case, the decl_iterator is actually rather trivial, it is effectively:

int i = 0;
CXCursor currentDecl = Handle.GetDecl(i);

do
{
    yield return TranslationUnit.GetOrCreate<Decl>(currentDecl);
    currentDecl = currentDecl.NextDeclInContext;
}
while (!currentDecl.IsNull);

If LazyList changed the signature of valueFactory from Func<int, T> to instead be Func<int, ROSpan<T>, T>>, then each iteration could pass in the already initialized elements. i.e. 0 is empty while 2 contains elements 0 and 1.

This would allow the implementation to be something like this:

_decls = LazyList.Create<Decl>(Handle.NumDecls, (i, initializedDecls) => {
        if (i == 0)
        {
            return Handle.GetDecl(0);
        }
        else
        {
            return initializedDecls[^1].NextDeclInContext;
        }
    }
);

[rolfbjarne]

I tried your suggestion, and it works! Speed increase is quite comparable (not sure if it's worse or better, because I'm not using the exact same test case, but it's very much in the same ballpark).

Also it's a fully managed solution, so existing tests work fine.