Intern a type node. Returns existing index if structurally identical node already exists, otherwise allocates and returns new index.

Look up a type alias by name.

Look up a type by index.

Number of entries (variables + concrete types) in the storage.

Helper: extract param and body from a lambda RootTy, panicking otherwise.

Convert a byte offset to an LSP Position (0-indexed line and UTF-16 character offset).

Send shutdown + exit. Call this at the end of each test for clean teardown (avoids "server not shut down" warnings).

Parse `# ^<num>` marker comments from source. Embed `# ^<num>` comments in test source where `^` points to the column on the **previous line** where

Access the OutputTy node at the root.

Open a file and wait for its initial diagnostics. Convenience for the common `open() + wait_for_diagnostics()` pattern.

Record that `sub <: sup` — `sub` is a subtype of `sup`.

Allocate a concrete type and return its TyId. Normalizes negations via double-negation elimination and De Morgan: - `Neg(Neg(x))` → `x` - `Neg(Inter(

Allocate a primitive type, deduplicating via cache.

Parse `# ^<num>` markers from a file and return `BTreeMap<u32, Position>`. Reads the file from disk, calls `parse_markers()` to get byte offsets, the

Load declarations from a parsed .tix file into the registry.

Assert both parsers produce the same ParsedTy for the given expression.

Canonicalize and return an owned OutputTy. Looks up the arena-interned result from `canonicalize_child`. Use this when you need to inspect/transform t

Run the full syntax pipeline: parse → lower → module indices → scopes → name resolution → SCC grouping.

Helper to build a flat PkgTree entry (no children).

Allocate a fresh type variable at the current level.

Convert a rowan TextRange to an LSP Range.

Convert a FileAnalysis into a FileSnapshot. Used by tests and the transitional period where both representations coexist.

Constrain sub <: sup, locating any error at the current expression.

Helper: write a temp .nix file and return its canonical path.

Build a simple OwnedTy from a closure that populates an arena.

Record that `bound` is a lower bound of variable `var` (bound <: var).

Extract the type string and optional doc string from hover contents.

Parse Nix source containing an if-then-else, run analyze_condition on the condition, and return (NarrowInfo, Module) for assertions.

Infer the type of an expression and record it in the expr→type map.

Try to find the definition location for the symbol at the given cursor position.

Infer a file and all its transitive imports on demand. If the file is already cached, returns the cached signature immediately. If another thread is

Extract attrset fields from a type, unwrapping Named, Intersection, and Union wrappers as appropriate.

Run completions at all marker positions. Returns marker → completions.

Entry point: try to produce completions for the given cursor position. `line_index` and `root` may come from a fresher parse than `analysis` — when t

Helper: hover at a byte offset and return the hover contents.

Generate a .tix file from a recursive tree of classified nixpkgs attributes. Classification rules: - `type == "set" && is_derivation` → `val name ::

Wait for a `publishDiagnostics` notification for the given file. Skips non-matching notifications (e.g. `window/logMessage`, diagnostics for other fil

Hover at a given line/character position.

Run type inference and return collected results + diagnostics.

Low-level: send a JSON-RPC request and return the response.

Update file contents and re-run analysis. Returns the cached analysis and a timing breakdown of each pipeline phase. Uses cache-only import resolutio

Create a displayable wrapper for a type.

Allocate a fresh type variable at the current level.

Helper: compute code actions at a marker position (zero-width range).

Build an AnalysisState and analyze a file, returning everything needed to call goto_definition.

Helper: build a simple closed AttrSetTy from field name-type pairs using an arena.

Allocate a fresh type variable at the current level.

Render the type with truncation limits applied.

Record that `bound` is an upper bound of variable `var` (var <: bound).

Derive glob patterns from a list of files of one kind. `all_files` contains every classified file across all kinds — used to detect mixed-kind direct

Get the pre-allocated TyId for a name (used during inference of the name's own definition, before it has been generalized).

Build inference layers from a file-level import graph. Input: map from canonical file path → list of its canonical import targets (already filtered t

Helper: build a HashMap from a list of (file, deps) pairs using simple string paths for readability.

Find the byte offset of a pattern in source text.

Load declarations from a parsed .tix file, recording source locations for type aliases and modules so `textDocument/typeDefinition` can navigate to th

Set the override directory for built-in context stubs. When resolving `@nixos` or `/** context: nixos */`, the registry will check for `<dir>/nixos.ti

Store a file's signature in the cache (passive mode). Returns `true` if the signature changed (callers use this to decide whether to trigger dependent

Helper: parse Nix source and return the syntax pipeline results.

Assert that `stdout` contains a binding line matching `name :: ty_fragment`. The type fragment is checked as a substring of the type portion, so you c

Get the cached root type for a file, if available.

Extract titles from code actions.

Add (or update) a .nix module file at the given path relative to the project root. Parent directories are created automatically.

Generate a primitive value as Nix text, for use in narrowed branches.

Run completions at all `# ^N` marker positions in the file.