Analyze stale source, then run the unified completion() with a fresh parse of different source. Simulates the pending_text scenario: the analysis is f

Helper: create an OutputTy::Union with arena-interned members.

Canonicalize a `Ty<TyId>` into an arena-interned `TyRef`. Compound types (Lambda, List, AttrSet, etc.) require their child `TyId`s to be canonicalize

Collect attrset fields from ALL union variants (not just common ones). Unlike `collect_attrset_fields` which intersects union members (only keeping f

LSP error indicating the document has been modified and the request should be retried. Editors like VS Code and Neovim handle this gracefully by autom

Helper: set up a multi-file project, analyze all files, then rename at a marker in the first file. Returns the RenameResult.

Extract the workspace edit from the first code action with the given title.

Look up the doc comment for a field within a type alias. `alias` is the type alias name (e.g. "NixosConfig"). `path` is the dotted path to the field (

Filter out diagnostics on lines suppressed by `# tix-ignore`. For each diagnostic, resolves its source location to a 0-indexed line number and remove

For exported type aliases that contain `typeof varname`, return the set of binding names whose types need to be inferred.

Collect 0-indexed line numbers whose diagnostics should be suppressed. For each `# tix-ignore` comment on line N, the *next* line (N+1) is added to t

Try to find the type definition locations for the symbol at the given cursor position. Returns LSP `Location`s pointing to the `.tix` file(s) where t

Check if a TyId refers to a type variable (not a concrete type).

Wrap a `TyRef` and the arena it lives in as a self-contained `DiagTy`.

Find the NameId under the cursor. Works on both definition sites (where a name is bound) and reference sites (where a name is used). When the cursor

Negate an OutputTy, applying normalization rules: 1. `¬(¬A)` → `A` (double negation) 2. `¬(A ∨ B ∨ …)` → `¬A ∧ ¬B

Open a file by absolute path (for use with `from_existing` workspaces).

Convert an `OwnedTy` (OutputTy in a TypeArena) to a `ParsedTy`. This conversion is lossy: `Named` wrappers are discarded, `Neg` types become `Top`, a

Try to parse a doc comment string as an inline type alias declaration. Returns `Some((name, body))` if the string matches `type Name = ...;`. Returns

Pick a field name from a module path in the expected fields map. Falls back to "id" if the path doesn't exist.

Check if two LSP ranges overlap (share at least one character position).

Record the import dependencies for a file via the coordinator.

Find references at a given line/character position.

Run batch warmup for a set of files using layered parallel inference. Results are returned for the caller to merge into LSP state. Results are return

Low-level: send a JSON-RPC notification (no response expected).

Check whether inference should bail out due to memory pressure. Caches a positive result in `bailed_out` so subsequent checks are O(1).

Simplify `(A | B) & ~T` by removing union members that are subtypes of `T`. Distributes the negation constraint into the union: (A | B) & ~C = (A &

Attempt to resolve the pinned nixpkgs path via `nix eval --raw .#nixpkgs-src`. Returns `None` if nix is not installed or the flake eval fails, allowi

Wait for `publishDiagnostics` for a file given by absolute path.

Get inference even if stale (for graceful degradation).

Generic tree traversal: returns true if any node matches `pred`.

Canonicalize a TyId into an OutputTy using only a TypeStorage reference. This captures the type's canonical form at the current moment — before use-si

Capitalize the first character of a string (e.g. "lib" -> "Lib").

Stable error code for this diagnostic kind.

Demand resolved type exports for a file. Returns the fully resolved exports where `TypeOf(name)` has been substituted with the actual inferred type vi

Find the expression to pass to detect_conditional_fn. Navigates through Lambda wrappers to find the inner expression.

Compare two snapshots and produce a diff report.

Check if two types have the same top-level constructor (discriminant).

Expand bounds of a variable into a union (positive) or intersection (negative). Shared logic for both polarities: 1. Canonicalize each bound at the g

If the expression is a Reference that resolves to a local Definition, return its NameId. Returns None for builtins, with-exprs, or unresolved names —

Extract type alias declarations from a Module's doc comments. Returns a map of alias name → ParsedTy body. These are the types that other files can im

Build completion items from attrset fields, optionally enriching each item with doc comments from the DocIndex. `doc_ctx` is `Some((docs, alias_name,

Walk lower bounds of a variable to find a concrete type, if one exists. Delegates to `resolve_to_concrete_id` to avoid duplicating the traversal and c

Look up the type of a named binding by text name, with aliases loaded. When the same name has multiple NameIds (e.g. definition + inherit reference),

Go-to-definition at a given line/character position.

Infer a branch body with type narrowing overrides applied. If `narrow_info` contains narrowings for the relevant branch, creates branch-local type va

Helper: parse Nix source and lower to Module.

Get the list of stub file/directory paths.

All reference ExprIds that resolve to the given NameId.

Rename a name at the given position to `new_name`, producing a workspace edit. When `state` and `current_path` are provided, also scans other open fi

Scan a Module for file paths referenced in type-level annotations (`import("path").TypeName` and `typeof import("path")`). Returns the set of relative

Register a source root for resolving `@source` annotations. e.g. `set_source_root("nixpkgs", "/nix/store/...-source")`.

Update the level of a variable. Used to lift pre-allocated vars to the SCC group level so they are correctly generalizable.

Source roots for resolving `@source` annotations in `DeclLocation`s.

Convert collected TixDiagnostics into LSP diagnostics. Each diagnostic is mapped to the source range of its associated expression, falling back to the

Set the base directory for resolving relative paths in type imports.

Helper to write a minimal flake.lock with the given root inputs. Each input is (input_name, node_key, owner, repo).

Check whether two concrete types are provably disjoint (their intersection is uninhabited). Delegates to the shared `are_shapes_disjoint` logic in `la

Build a name→import-path mapping from grouped definitions and import targets. For each let-binding or attrset field whose value expression is a resol

Build a TypeAliasRegistry from CLI flags, loading stubs and validating. This consolidates the repeated registry setup across run_check, run_gen_stub,

Return the cache directory path (`~/.cache/tix/store-stubs/`). Returns `None` if the platform has no standard cache dir.

Create a RootTy for a child TyRef (shares the same arena).

Delete entries of the given `kind` from `dir`. Returns the number removed. Entries of the opposite kind are skipped. Missing `dir` is a no-op (returns

Returns true if this type or any child contains a Union or Intersection.

Delegate to the arena's contains_union_or_intersection.

Parse `flake.lock` in the project root and detect nixpkgs/home-manager inputs. Returns `None` if there is no `flake.lock` or it doesn't contain a nix

Produce a deterministic string fingerprint of the custom-systems config. Systems are emitted in sorted-name order so hash stability doesn't depend on

Record a warning at the current expression.

Helper to build a CollectError with span information from a pest Pair.

Get the concrete type for a TyId, panicking if it's a variable.