Scan a module for all import paths without resolving types. Combines `scan_literal_imports` and `scan_callpackage_imports`, normalizes paths, applies

Scan a module's AST for `callPackage <literal-path> <overrides>` patterns. The Nix desugaring of `callPackage ./pkg.nix {}` is: `Apply { fun: Apply {

Scan a module's AST for `import <literal-path>` patterns. Walks all expressions looking for Apply nodes where: - `fun` is a Reference("import") that

Schedule analysis for a file. The text is stored immediately in `pending_text` so that request handlers (e.g. completion) can re-parse it on the fly,

Find the scope at the given token by walking ancestor syntax nodes until one maps to an ExprId with a registered scope. When the token is whitespace

Selection ranges for multiple positions in a file.

Extract the signature label from a SignatureHelp result.

Entry point: try to produce signature help for the given cursor position. Walks up from the cursor token looking for enclosing Apply nodes. When foun

Signature help at a given position.

Helper: sort a layer's file names for deterministic comparison.

Print a summary table to stderr.

Synthesize the `builtins` attrset containing all known builtins as fields.

Synthesize the type for a named builtin. Returns fresh type vars for polymorphic builtins so each reference is independent.

Translate a noogle type signature to .tix syntax. Returns a TranslationResult with the translated signature or a reason for failure.

Check if `var_expr` is a reference to a local name and `literal_expr` is a recognized literal (null, true, false, int, float, string, path). Returns t

Best-effort load of a module stub from `builtin_stubs_dir`. Given an alias name like `"Pkgs"`, looks for `pkgs.tix` in the stubs directory. If found

Check if a Union type tree contains a specific TyId as a leaf member. Used for union absorption: `(A ∨ B) ∨ B = A ∨ B`. When variable isolation create

Unwrap nested let-in expressions to find the inner body.

Store or update the file signature in the coordinator cache. Returns `true` if the type actually changed (callers use this to decide whether to trigge

Convert a batch of `LocatedWarning`s into `TixDiagnostic`s.

SymbolInformation.deprecated field is deprecated but required

SymbolInformation has deprecated fields

Serialize the JSON output to stdout.

Recursive generator for guard conditions on `__narr_x`. Leaves: type predicates, compound predicates, literal equality, hasField. Recursion (depth 2)

Generate a ParsedTy leaf that may or may not be a TypeOf.

Leaf strategy producing (RawTy, NixTextStr) for primitive types.

Build a GlobSet from the `[project] exclude` patterns.

Build a `FileAnalysis` from inference inputs and check result. This is the legacy path used during the transition — handlers will eventually read from

Build the nix expression for evaluating Home Manager options.

Create a user-owned merged-stubs directory at `~/.cache/tix/custom-stubs/<cache_key>/`. The directory contains copies of every `.tix` file from `built

Build the full nix expression that imports extract-options.nix and passes the correct `options` argument.

Build the nix expression that recursively classifies nixpkgs attributes. For each attr, we try to evaluate it and record: - `type`: result of `builti

Build `SignatureHelp` from a function type (as arena + TyRef), the number of parameters being applied, and the active parameter index.

Build a NixTestCase for a given pattern index and stub set.

Capitalize a name for use as a type alias reference (first char uppercase, rest unchanged). Module names like `python313Packages` become `Python313Pac

Capitalize the first character of a string.

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

Check that braces, brackets, and parens are balanced.

Check if a cached store path exists and is still valid.

Check doc comments for `/** context: X */` annotations.

Type-check Nix source from scratch (parses, lowers, resolves, infers). Convenience for tests and simple callers.

Helper to type-check a string with context args applied to the root lambda.

Classify a bare attrset (not inside a lambda).

Classify a single file, returning None if parsing fails.

Classify an identifier token using the source map and name resolution.

Classify a single syntax token. Returns (token_type_index, modifier_bitset) or None if the token should be skipped (whitespace, delimiters, etc.).

Delete all entries in both cache dirs (`store-stubs/` and `custom-stubs/`). Returns the combined counts + dirs, or `None` if the platform has no stand

Collect deduplicated binding types and root type from inference results. Returns `(bindings_map, root_type_string)`. Both are empty/None if inference

Collect top-level attrset keys from the body expression. If body is a let-in, looks at the inner body. If body is an attrset, collects its static key

Scan all open files for imports pointing at `current_path`, and collect TextEdits that rename Select field references from `old_name` to `new_name`.

Collect NameIds that have an existing diagnostic targeting them. Uses the source map to map ExprId → NameId where possible.

Walk UP the syntax tree from the cursor token to find a callsite (Apply node) and collect the nesting path along the way. Path steps are ordered bott

Recursively collect doc comments from module val declarations and register them as field docs on the capitalized module alias.

Collect all symbol names (including children).

Recursively collect .nix files under `dir`, excluding `tests/` and `deprecated/` path segments.

Peel off Lambda layers from a function type to extract parameter TyRefs. Stops after `max_params` or when the type is no longer a Lambda.

Recursively collect resolved Nix-file path literals from an expression subtree.