Collect all `TypeVarValue::Reference` names from a ParsedTy.

Collect the attrpath segments that have already been typed (i.e. that have a string literal in the lowered AST). The final segment (the one being comp

Collect a union type from its children: `isect_type ("|" isect_type)*`. If only one member, returns it directly (no spurious Union wrapper).

Collect unique parent directories from a list of classified files.

Like `collect_visible_names` but doesn't require inference results. Uses inference types opportunistically when available (from stale analysis), but

Compact the bounds graph for an SCC group's type slots. Runs three passes over `[slots_before..len)`: 1. **Pin**: Replace fully-determined variables

Find pipeline functions whose input matches the given type. For Bare access, only return functions that have top-level global vals.

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

Compress a set of other-kind files into exclude patterns. Groups files by their parent directory. When 2+ other-kind files share a subdirectory AND n

The core computation: extract syntax, scan imports, demand dependencies, build InferenceInputs, run inference, extract signature.

Compute the override TyId for a single NarrowBinding. Given a predicate and the name it narrows, returns a TyId representing the narrowed type as `In

Build scopes for a module.

Lazy field-level materialization for `AttrSet <: Frozen(OutputTy)`. Mirror of `constrain_frozen_attrset`. For each field in the sub attrset, look it

Width subtyping for attribute sets: the sub-type must have every field the super-type has, and each field must be a subtype. The sub-type can have ext

Structural subtyping between two concrete types. `sub_id`/`sup_id` are the original TyIds from `constrain()` — passed through so that Inter/Union dec

Lazy field-level materialization for `Frozen(OutputTy) <: AttrSet`. Instead of interning the entire frozen OutputTy (which may have hundreds of field

Lazy structural decomposition for `Frozen(OutputTy) <: Lambda`. For large imported types (e.g. hackage-packages.nix returning a 16K-field attrset), i

Mirror of `constrain_frozen_lambda` for `Lambda <: Frozen(OwnedTy)`.

`Inter(a, b) <: sup` — the "annoying" case. Use variable isolation (MLstruct-style) when one member is a variable. Before applying variable isolation

`sub <: Union(a, b)` — route the sub-type to the correct union member. Uses a two-phase approach: try concrete match first, fall to variable. This av

Returns true if this type is or contains a bare TyVar outside Lambda params.

Returns true if this type or any child contains an Intersection.

Returns true if this type contains a Named wrapper.

Returns true if this type or any child contains a Neg.

Returns true if this type is or contains Top or Bottom.

Like `contains_union`, but expands alias references via a lookup closure. This catches unions hidden behind type aliases (e.g. `Nullable = int | null`

Check if two context names are compatible (allowing aliases).

Create a temp directory that mimics a nixpkgs checkout: tix.toml at root + a pkgs/ file. Returns the root PathBuf (caller is responsible for cleanup).

Decompose a narrowing override `Inter(base, constraint)` into its parts. After this fix, overrides always have the shape `Inter(var, C)` where C may

Batch inference: infer all files in parallel with demand-driven import resolution. Returns results in the same order as the input files.

Check if `fun_expr` is `Apply(conditional_fn, cond)` where `conditional_fn` is a known conditional library function. If so, analyze `cond` for narrowi

Auto-detect the common /nix/store/...-source/ prefix across all entries. Noogle data references a single nixpkgs store path for all positions.

Extract the set of variables that were visited at both polarities during canonicalization. Used by the two-pass strategy.

Document highlight at a given position.

Document links for a file.

Standard Levenshtein edit distance between two strings.

Recursively emit val/module declarations for a package tree at the given indentation level. Names that cannot be valid bare identifiers are emitted as

Convert a single `LocatedError` into a `TixDiagnostic`. Each error gets its own arena so that diagnostics are fully self-contained and can be stored,

Fallback when a variable has no concrete bounds in the given polarity. - **Positive**: check for atom-only upper bounds (primitives, negations of pri

Map NixFileKind to expected context name (if any).

Count the number of visible nested lambda parameters in an expression. For `x: y: body`, this returns 2. For a non-lambda, returns 0.

If the expression is a literal (or a keyword like null/true/false that is represented as a Reference in the AST), return the corresponding NarrowPrimi

Extract a field's type from a TyId that should be an AttrSet.

Extract the path string from an import_path rule.

Extract the path string from an import_path rule: `import_kw "(" string_literal ")"`.

Walk an OutputTy function type to extract the AttrSet field types from the parameter position. Returns a map of field name → TyRef within the same are

Extract the element type from a list type, unwrapping Named and Union/Intersection wrappers as needed.

Extract the main 'name :: type' line from a possibly multi-line signature. Returns just the type part (after ::), or None if we can't parse it.

Extract the parameter type from a TyId that should be a Lambda. Follows Named wrappers and single-lower-bound variables.

Extract the return type from a TyId that should be a Lambda.

Peel one Lambda layer from a type to get the return type. `callPackage` applies the dependency-injection argument (the first parameter of the package

Extract a named type alias from Nix source by scanning `/** ... */` blocks.

Collect NameIds of fields in the root-level attrset, chasing through LetIn bodies (Nix files commonly have `let ... in { fields }` at the top).

Find and load tix.toml configuration. Returns the config and its directory.

Find the insertion point for a new field in an attrset definition. Given the `set` ExprId of a Select (the thing being accessed), chase through name

Find the `set` ExprId of the Select expression that contains `attr_expr` in its attrpath. The MissingField diagnostic's `at_expr` points to the attrp

Try to find a static binding named `field_name` in the expression `expr_id`. Handles two cases: - Direct attrset literal: `{ field_name = ...; }` - O

Find the generate-stubs-runtime.nix shipped with the tix package.

Find the first `IfThenElse` expression and return its condition ExprId.

Walk up from a syntax node through ancestors, collecting the outermost Apply node that forms a contiguous application chain. For `f a b c` (parsed as

Scan an expression subtree for a single path literal that resolves to a Nix file. This is a heuristic fallback for patterns like `pkgs.callPackage ./

Find all references to a name, including cross-file references via imports. Extends `find_references` with cross-file search: - If the cursor is on a

Look for "outer" with a child "inner".

Walk the `with` chain (innermost first) and return the `AstPtr` for the first environment that statically contains `field_name` as a binding key.

Set up an AnalysisState pointing at the test/nixos_fixture/ directory. Loads the fixture's tix.toml and configures the state so that context resoluti

Post-process translated records to ensure .tix syntax compliance. - Remove trailing commas before `}` - Ensure open records have `...` before

SymbolInformation.deprecated field

Flatten an Apply chain into a list of (function, argument) pairs in application order (first param first). For `Apply(Apply(Apply(f, a), b), c)`: - o

Collect all leaf (non-Union) members from a possibly nested union tree.

Visit every direct child TyRef for read-only inspection.

Format a description for emission as `##` doc comment lines. By default, uses only the first paragraph (up to the first blank line).

Format a field name, quoting it if it contains characters not valid as bare identifiers (e.g. dots in `net.core.rmem_max`).

Format a manually-maintained module block with optional submodules. Each entry is (val_name, type_signature, doc_comment_or_None).

Get documentation for a parameter type (e.g. listing pattern fields).

Format a single parameter type for the signature label. For attrset types (pattern parameters), shows a condensed field list. For other types, uses t

Format the signature label and parameter labels for display. For a function type `a -> b -> c`, the label is `a -> b -> c` and the parameter labels a

Try to format a `NixPosition` as an `@source` annotation string. Strips the absolute path against configured source roots to produce a relative annot