Add AST module caching support for LSP

[JoshuaBatty]

Description

This PR supersedes #4988 and builds on backend work done by @tritao in #4733.

A new ModuleId is created for each compiled module. The SourceId type now also stores the ModuleId that was used to create it. This allows us to perform garbage collection on types in the Declaration and Type engines that refer the provided module.

if let Some(module_id) = engines.se().get_module_id(&path) {
    engines.clear_module(&module_id);
}

This method isn't super cheap to call. My tests had this averaging at 54ms. We are currently performing garbage collection on every key stroke in LSP. We should look to have another metric such as only clearing once every 20 keystrokes or so in the future.

I ran benchmarking on recompiling the doc_comments example 20 times to simulate rapid keystrokes during coding. Here are the results.

Without Caching	With Caching
89.489 s	4.6236 s

A speed up of 1835.49% is certainly great, yet 4.6 seconds still sounds like an eternity. Still have lots of room to improve but this should improve our current system dramatically.

closes #4994

Checklist

• I have linked to any relevant issues.
• I have commented my code, particularly in hard-to-understand areas.
• I have updated the documentation where relevant (API docs, the reference, and the Sway book).
• I have added tests that prove my fix is effective or that my feature works.
• I have added (or requested a maintainer to add) the necessary Breaking* or New Feature labels where relevant.
• I have done my best to ensure that my PR adheres to the Fuel Labs Code Review Standards.
• I have requested a review from the relevant team or maintainers.

[tritao]

Really nice work, the speed up is massive!

This method isn't super cheap to call. My tests had this averaging at 54ms. We are currently performing garbage collection on every key stroke in LSP. We should look to have another metric such as only clearing once every 20 keystrokes or so in the future.

Calling it on every keystroke certainly seems excessive, even on every couple keystrokes. I think it could be worth thinking about having a memory size heuristics-based system instead, and calling it on idle time so it's less perceptible to the user.

[IGI-111]

Very nice. It probably needs to be tuned further, but it's a great start and much cleaner than I would have expected for something like this.

[JoshuaBatty]

Great, I'll start think about a nice heuristic to call gc from.

[sdankel]

Amazing performance improvement!

[tritao]

Overall looks great, though it seems some of the type engine insertions have a None source id. As far as I can tell, that means we won't track those, so we won't be able to GC them, right? Assuming that's the case, something we should look into improving in the future.

[JoshuaBatty]

Overall looks great, though it seems some of the type engine insertions have a None source id. As far as I can tell, that means we won't track those, so we won't be able to GC them, right? Assuming that's the case, something we should look into improving in the future.

Good question, at the top of the type engines insert function we check if None was provided

let source_id = source_id.map(Clone::clone).or_else(|| info_to_source_id(&ty));

If it's None then we try to map the type_info to a reserved source id.

/// Maps specific `TypeInfo` variants to a reserved `SourceId`, returning `None` for non-mapped types.
fn info_to_source_id(ty: &TypeInfo) -> Option<SourceId> {
    match ty {
        TypeInfo::Unknown
        | TypeInfo::UnsignedInteger(_)
        | TypeInfo::Numeric
        | TypeInfo::Boolean
        | TypeInfo::B256
        | TypeInfo::RawUntypedPtr
        | TypeInfo::RawUntypedSlice
        | TypeInfo::StringSlice
        | TypeInfo::Contract
        | TypeInfo::StringArray(_)
        | TypeInfo::Array(_, _) => Some(SourceId::reserved()),
        TypeInfo::Tuple(v) if v.is_empty() => Some(SourceId::reserved()),
        _ => None,
    }
}

This way we don't clear types that are shared between modules, and type_info variants that can hold spans are allowed to be None, thus can be cleared safely.

[JoshuaBatty]

Calling it on every keystroke certainly seems excessive, even on every couple keystrokes. I think it could be worth thinking about having a memory size heuristics-based system instead, and calling it on idle time so it's less perceptible to the user.

I'm now only calling it on every 10th keystroke. Unfortunately we can't call it during idle as this would remove internal types needed for doing goto def, hover etc in the users workspace.

[JoshuaBatty]

hmm calling it on every 10th keystroke is causing CI to run out of memory. I'll open an issue and we can work on this optimisation in a follow up PR.