Walk up from `start_dir` looking for `tix.toml`. Returns the first match.

Collect free type variables in order of first appearance, deduplicated.

Collect free type variable ids in DFS order of first appearance, deduplicated. Matches `TypeArena::free_type_vars` which preserves first-appearance or

Return the set of files that import the given path (its dependents).

Helper: run partial inference up to a given group and return a name's type.

True iff `id` was marked by `mark_default_param`.

True when `self` is a proper subtype of `other` (excluding reflexivity, which is handled separately). Currently only Int <: Number and Float <: Number

Apply `f` to every direct child TyRef, producing a new OutputTy with the same variant structure.

Normalize a collected member list into a single type: - 0 members → error with `kind_name` - 1 member → unwrap to avoid a spurious wrapper - 2+ member

Parse multiple files and return a map of path → SyntaxResult. The first file is treated as the entry point and also returned separately.

Convert a `ParsedTy` to `OutputTy`, resolving type alias references through a `TypeAliasRegistry`. Shared by CLI and LSP code paths. `arena` is used

Core logic of [`build_merged_stubs_dir`] that takes the output directory explicitly. Separated for testability.

Repo root, derived from Cargo's `CARGO_MANIFEST_DIR` (crates/cli).

Resolve an attrpath key token to its config type, full path, and alias name. Shared by hover, field doc lookup, and goto-def for config fields.

Resolve import types for a module using the coordinator's cache. Used by the LSP's Phase B as a drop-in for `resolve_import_types_from_stubs`.

Resolve a `SourceLocation` (from `@source` annotation) to an LSP `Location` by looking up the source root and constructing an absolute path.

Entry point for `tix init`.

Drop predicate for bare `TyVar` / `Bottom` / `Top` inside flattened union/intersection members. Bare `TyVar`s are uninformative as members of a compo

Structural cross-arena equality: compares two types from potentially different arenas by recursively comparing their OutputTy nodes. Unlike `PartialE

Try to extract a doc_block from the first child of `inner` if it matches. Returns `(Option<SmolStr>, Pairs)` -- the doc (if present) and the remaining

Try to extract a `source_annotation` from the next child of `inner`. Returns `Option<SourceLocation>` and consumes the pair if matched.

Like `for_each_child` but supports early exit via `ControlFlow`.

If all children of the concrete type at `ty_id` are themselves variable-free, mark `ty_id` as variable-free too. No-op for variables. Called after ext

Convert a NixOS type to a .tix type expression string.

Strip surrounding double quotes from a string literal.

Validate the registry for cycles in alias references. Returns `Err` with the names involved in cycles if any are found.

Wrap a Nix expression in the scaffolding needed by the access pattern.

Validate and write generated .tix content to a file or stdout.

Helper: write files to a temp dir and return (path, contents) pairs.

Allocate a primitive type, deduplicating via cache.

Allocate an open attrset type with a single field `{ field: field_ty, ... }`.

If `name_id` has a doc comment type annotation (e.g. `/** type: x :: int */`), constrain `ty` to match the declared type. Returns Ok(()) if no annotat

Assert that `stdout` contains a binding line matching `name :: ty_fragment`.

Chase through Apply chains to find an import target path. `import ./foo.nix { args }` desugars to `Apply(Apply(import, ./foo.nix), { args })`. The in

Type-check with both custom aliases and context args.

Classify a Nix file by analyzing its AST structure. Only depends on the parsed Module and NameResolution — no type inference needed. Checks for expli

Collect field names already present in an attrset literal, using the lowered AST (Bindings) rather than re-parsing rnix. We look up the AttrSet's Expr

Collect field names already present in an attrset literal by walking the fresh rnix tree directly. Unlike `collect_existing_fields`, this does not nee

Collect a single type from a Pair. Dispatches on the pair's rule and processes its children. Unlike `collect_type_expr`, this does NOT treat remaining

Request completions at a given line/character position.

Map a type to the appropriate LSP CompletionItemKind.

Compute importer counts for reference-counted eviction. Returns a map from each file to the number of in-project files that import it. Files with 0 i

Convert context args (from tix.toml) to OutputTy, sharing a single arena.

Detect `Apply(conditional_fn, cond)` where conditional_fn is a known conditional library function. If so, analyze `cond` for narrowing and return the

URL to the documentation page for this error code.

DocumentSymbol.deprecated is deprecated but required by the struct

Expand type alias references in a ParsedTy. Replaces Reference("Foo") with the alias body from the registry. Depth-guarded to prevent cycles.

Extract a compacted `FileSignature` from a `CheckResult`. Returns `None` if inference failed or the root expression has no type. This is the shared l

Extract the identifier text from a simple expression node (Ident). Returns None for complex expressions like function calls or nested selects.

Find the first occurrence of `name =` (a let-binding or attrset field) in `source` and return its 0-based `(line, col)`.

Check if a file path matches any context. Returns the context name if matched, or None.

Find a name's type by searching the stale module for a NameId with matching text, then looking up its type in inference results. Prefers names that h

Find the first occurrence of `name` as a pattern field in `{ name, ... }:` and return its 0-based `(line, col)`.

Find the project root by walking up from `start` looking for flake.nix or .git.

Given a binding name and grouped defs, find the SCC group index that contains the binding. Returns None if not found.

Format a description as a .tix doc comment (## lines).

Full-document range for requesting all inlay hints.

Extract a plain string literal from an rnix Str node (no interpolation).

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

Check whether an intersection contains a contradictory pair. Two kinds of contradictions: 1. `T ∧ ¬S` where `T <: S` (subsumption). E.g. `Int ∧ ¬Numb

Hover at a position in a file given by absolute path.

Helper: set up a NixOS module context and hover at markers.

Inlay hints for a range in a file.

Insert a declaration-level doc.

Insert a field-level doc.

Invalidate a file and all its transitive dependents. Returns the list of paths that were evicted (excluding the root path itself).

Run `nix eval --json --impure --expr <expr>`, parse the JSON output into an option tree. `label` is used in the progress message (e.g. "NixOS").

Whether this name kind represents a parameter (genuine polymorphism). Param/PatField keep letter names; all others use `?` for unknowns.

Whether this diagnostic is a warning (true) or an error (false).

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

Load .tix files from a path. If the path is a file, load it directly. If it's a directory, recursively find all .tix files and load them.

Create a fixture project using `@builtin` context references. If `override_stubs` is provided, the registry's builtin stubs dir is set to a temp dire

Helper: create an OwnedTy from a primitive OutputTy for tests.

Mark a pattern-field name slot as having received a `? default` lower bound. Idempotent. Consulted by canonicalization's Negative empty-fallback to sk

Convert a module's declarations into an open attrset ParsedTy. Val declarations become named fields; nested modules become nested attrset fields. Eac

Check if `normalize_replacing_unknown` would actually mutate the arena. Returns false when the type has no free vars and isn't a bare TyVar, meaning n