[ngua]

This is essentially a complete rewrite of the inferno-lsp server to fix critical memory and performance issues. These really were serious enough to warrant a rewrite (see details below). The external API of the LSP is preserved (i.e. anything establishing a connection to the LSP). The only non-backwards-compatible changes are in the introduction of the LspConfig record instead of eleven positional arguments, but that's a trivial switch at a very small number of call sites for us.

NOTE: I did not change the version of lsp that we're using. I figured this introduced enough changes and updating would not be worth the additional churn or unexpected issues. So I've kept us on the same version as before for now.

Major issues in previous implementation

Unbounded hover map growth

This was by far the largest problem with the previous implementation, but it was also tied closely to other parts explained below. This problem alone warranted a significant rewrite IMO.

The old server built up hover entries across every document version into a single global map, keyed by (NormalizedUri, Int32). DidChange inserted new version keys without evicting old ones. This means the map grew without bound while the server ran. Even though the main entrypoint for Inferno LSP is one server-per-session, a normal, long-running editing session could accumulate enough memory in the main process address space to kill it (I mean without any adversarial intent, which is another story).

A long-running inferno-lsp server process could theoretically consume as much memory as available to the process, just for hovers! This, coupled with the poor parser performance and O(n^3) typechecking algorithm (both now fixed separately), is probably the largest single cause of the degenerate behavior we've seen from inferno-lsp.

Now we use a per-document (not global) TVar DocState inside a concurrent StmContainers.Map. Each document's hover state is replaced (not appended) on every successful analysis. DidClose cancels any current work and removes the document from the store entirely.

No debouncing or cancellation

Previously, every keystroke triggered a full parse/infer pipeline with no debounce and no way to cancel the previous task. During any actual editing this implied dozens (or more) of redundant pipeline runs piling up, each holding intermediate ASTs and type maps in memory until completion, with no way to cancel them. This is true for single documents, i.e. a single editing session could accumulate thousands of full parsing and inference jobs without any cancellation.

The new server implements per-document debounce and cancellation: each DidChange cancels the previous document's in-flight Async (which interrupts the threadDelay immediately since it's an interruptible operation), then spawns a new async that waits debounceMs (default 150ms) before running the pipeline. A version guard (whenCurrentVersion) prevents stale results from overwriting fresh diagnostics (possible race condition).

Eager findTypeClassWitnesses at parse time

The old server called findTypeClassWitnesses for every AST node in the type map during parsing which built markdown hover content eagerly. Finding typeclass witnesses can be an expensive combinatorial search that should only run for the single node the user is actually hovering over.

Now findTypeClassWitnesses is deferred to hover-request time only and runs it for the one queried node. The result is cached in an IntMap keyed by the linearized position so repeated hovers on the same position are not recomputed. The cache is invalidated on every analysis update since source positions shift.

O(n) hover lookup

The old code scanned the entire type map linearly on every hover request, checking whether the cursor position fell within each span. For large scripts with hundreds of type annotations this could be tangibly slow (I mean when actually using the script editor).

This is fixed with an IntervalMap with linearized source positions. Point queries are now O(log n). The smallest enclosing interval is selected to give the most specific (innermost) type.

Unsafe/partial list indexing in completion

completionQueryAt used Text.splitOn "\n" followed by !! fromIntegral line, which could crash on out-of-bounds positions or degenerate inputs.

The rewrite computes line starts via scanl' and uses a total drop and pattern-match with clamping to document length if the position lies beyond the end.

Reactor channel (unbounded work queue)

The old architecture serialized all notifications and requests through a single TChan ReactorInput. This queued hover requests behind stale DidChanges and the channel could grow without bound during bursts.

The reactor has been removed entirely. The lsp library itself already provides concurrency and handlers execute directly in LspT. Per-document asyncs are naturally serialized by the cancel-and-replace pattern, and read-only handlers (hover, completion) access current state immediately via STM with no need for queuing.

11 positional arguments to the server entry point

The old runInfernoLspServerWith took 11 positional arguments (!) (tracer, IO handles, module map, custom types, ident callback, validation callback, before/after parse callbacks, etc.). This was error-prone and hard to extend, and was also underdocumented

There's now an LspConfig c with named fields and sensible defaults. Callers supply a LspConfig c -> LspConfig c modifier to override only what they need. I kept runInfernoLspServer as a backwards-compatible wrapper that uses default config.

Make parseAndInferWithTimeout a real utility function

Previously, parseAndInferWithTimeout was linked to LSP-server lifecycle, dealt with document UUIDs, etc.... This was an overlapping of concerns: it really should just do what it says, i.e. parsing and inferring within a timeout. Calling it was awkward and required passing two const ... arguments (because they were always irrelevant) and then turning a four-tuple into a tuple. Again, this was because it was a "utility function" that was actually tied directly to an otherwise unrelated LSP server.

This has been addressed in the refactor -- it now only does exactly what it says. Call sites have been fixed.

Module reorganization

The previous implementation put almost everything in two files: Server.hs (handlers, types, initialization, reactor, diagnostics) and ParseInfer.hs (parsing, inference, hover rendering, completion, diagnostic conversion, and unused debugging utilities). I.e. there was no real separation of concerns.

Now there are focused modules with clear responsibilities:

• DocState: Per-document state types, DocStore (STM map), lifecycle operations (open/close/update/cancel). No LSP or language logic
• Hover: HoverIndex (interval map), linearization, point queries, hover content rendering (mkPrettyTy, metadataDocsText). No IO or STM
• ParseInfer: Parse/infer pipeline orchestration and diagnostic conversion. No hover rendering, completions, or STM. It does not handle input validation (domain policy) or HoverIndex construction (both belong to the Server)
• Completion: Completion prefix extraction, prelude/identifier/module/keyword filtering, CompletionItem construction. No IO or document state
• Server: Actual LSP handlers, LspConfig/Env, debounce/cancel orchestration, afterParse callback integration, diagnostic publishing. Delegates all other domain logic to the modules above

[Copilot]

Pull request overview

Refactors/re-writes inferno-lsp’s server implementation to address major performance/memory issues (unbounded hover growth, no debounce/cancellation, queued reactor architecture), while preserving the external LSP connection API and improving internal modularity.

Changes:

• Introduces per-document STM state (DocStore/DocState) with cancellation + debounced analysis, and removes the global reactor queue.
• Reworks hover and completion to be more efficient (interval-map hover index, deferred typeclass witness search, safer completion prefix extraction).
• Reorganizes LSP logic into focused modules and updates supporting packages (virtual record fields, cabal/changelog/version bumps).

Reviewed changes

Copilot reviewed 12 out of 12 changed files in this pull request and generated 3 comments.

Show a summary per file

File	Description
inferno-types/src/Inferno/Types/Syntax.hs	Adds HasField instances to enable OverloadedRecordDot accessors for positional types (ImplType, Scheme, TCScheme).
inferno-lsp/src/Inferno/LSP/Server.hs	New server architecture: per-document analysis lifecycle, debounce/cancel orchestration, diagnostics publishing, and config refactor.
inferno-lsp/src/Inferno/LSP/ParseInfer.hs	Separates parse/infer pipeline + diagnostic generation into a language-level module; provides timeout utility.
inferno-lsp/src/Inferno/LSP/Hover.hs	Adds interval-map hover indexing and markdown hover rendering with cached witness resolution.
inferno-lsp/src/Inferno/LSP/DocState.hs	Introduces per-document state and a concurrent DocStore with cancellation support.
inferno-lsp/src/Inferno/LSP/Completion.hs	Refactors completion prefix extraction to be total; restructures prelude filtering and item construction.
inferno-lsp/inferno-lsp.cabal	Bumps version, adds new modules/deps, and adjusts warning flags.
inferno-lsp/CHANGELOG.md	Documents the 0.3.0.0 rewrite.
inferno-core/src/Inferno/Module.hs	Removes an unused import from the module layer.
inferno-core/src/Inferno/Infer.hs	Removes HasField instances for ImplType (now centralized in inferno-types).
inferno-core/inferno-core.cabal	Bumps inferno-core version.
inferno-core/CHANGELOG.md	Adds entries for 0.11.7.0/0.11.8.0 (with a small typo to fix).

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[LTibbetts]

Overall great work and approved!

Requests:

• Clarify intent of error diagnostics always being at the start of the document

Potential Changes:

• Move the version check inside of updateDoc

If you feel like it:

• Negligible copilot comments like spelling, duplicate unused packages flag