GitLab

We can't really handle a single pipeline tracking load/unload/load, so
just disconnect our unload tracking after we have connected.

Instead, we rely on the build manager to reset the pipeline when the
configuration changes.

Creating a PTY with a cancellable will fail due to lower levels complaining
about socket initialization with cancellables. This works around it by
ensuring we don't propagate the cancellable to vte_pty_new_sync().

This is useful so that we can track when it changes and update the binding
in various UI components.

No need to imply the sink to the transfer of the call, so hoist this out.

Just to simplify the process of locating what indexers are at play.

Vala currently doesn't handle the null-terminated array of strings
being passed down correctly (const gchar * const *). This is a workaround
for it temporarily.

Not sure the exact version for these, but lets start with this.

We wanted to remove the use of indexers called from threads and
instead keep the communication between objects on the main
thread (and let indexers do their own off-thread work if they
so decide).

This isn't being used yet, but will allow us in the future to
potentially drop the full paths used in the index files and
instead use basenames for a healthy file size slimming.

We can change these a bit now that we know how they're getting
used in the new version of the code.

This is convenient for the code indexer, so lets require it of
the code entries to save us some pain.

This simplies the process of getting all the children in a directory and
the build flags for each file. It will not return ignored files as those
ignored by the VCS.

This is a convenience function to simplify the number of async callbacks
necessary to work through the data set.

We need to rewrite this to avoid using threads. This just stubs out the
same API for where we will start with.

This removes the "threaded" usage of IdeCodeIndexer and moves to
our new async/finish API.

It also creates a new CXIndex for each file, so we can more
reliably release memory after each parse. It probably means we
have to index some data more, but since this is a background
operation, I'd prefer to keep the memory usage lower at any
given time.

We don't want "threaded plugin API". Instead, we want objects that live in
the main thread, and have async/finish API (for which plugins can choose to
use threads if they like).

There is still plenty more to do, but this is a good check-in point
before fixing up things more.