Load context stubs for a named built-in context (e.g. "nixos"). If `builtin_stubs_dir` is set, checks for `<dir>/<name>.tix` first. Falls back to the

Build primitive TyRef helpers to avoid repeated arena.intern() calls.

Open a file (reads content from the TempProject on disk).

Simplify a type using co-occurrence analysis. Takes a mutable arena because simplification may intern new type nodes.

Allocate a concrete type and return its TyId.

Like `find_concrete`, but if the result is an `Inter(α, C)` where exactly one member is a concrete non-Neg, non-variable type, return that member. Thi

Find a NameId by its text. Panics if not found.

Record a phase boundary. The phase name should be a short label describing what just completed (e.g. "parse+lower", "inference").

Store a concrete (non-variable) type and return its TyId.

Generate a unique temporary file path for tests, avoiding collisions when tests run in parallel.

Canonicalize and return an arena-interned TyRef. When the same (TyId, Polarity) is used as a child from multiple parents, they share the same index —

Compute a cache key from input store paths and the Nix-literal strings describing extra modules to splice into the NixOS/HM evals. The extra-module st

Intern an OwnedTy as a single frozen TyId. Instead of eagerly converting the entire type tree into TyIds (O(N) allocations), wraps it in `Ty::Frozen(O

Intern an OwnedTy into this file's TypeStorage, creating fresh TyIds. Each TyVar(n) in the OwnedTy maps to a fresh variable (via a local HashMap). Th

Load inline type aliases from doc comments, applying CoW on the registry. Most files have no inline aliases, so the Arc is shared without cloning.

Merge two attrsets. Fields from `other` override fields from `self` (right-biased).

Like [`run_syntax_pipeline`], but wraps all work in a tracing span tagged with the file path so sub-spans (`parse+lower`, `module_indices`, etc.) appe

Helper: parse Nix source and classify it.

Constrain a ≡ b (bidirectional: a <: b and b <: a), locating any error at the current expression. Also records the equivalence in storage so that lat

Get a mutable reference to the entry. Used internally.

Merge multiple attrsets in an intersection into a single attrset. The intersection of `{ foo: int }` and `{ bar: string }` is `{ foo: int, bar: string

Convert an LSP Position (UTF-16 character offset) to a byte offset.

Prepare rename at a given position (validates rename is possible).

Read from the DashMap snapshot. The callback receives the FileSnapshot and the parsed rnix Root. Returns `ContentModified` if the file hasn't been ana

Infer a multi-file project with a custom TypeAliasRegistry. Pre-infers all dependency files (in order) to build ephemeral stubs, then infers the entr

Helper: type-check with CheckBuilder (which includes lowering diagnostics) and return just the diagnostics.

Structural comparison of inferred vs declared types. Reports mismatches as human-readable strings. This is a best-effort check — it catches missing fi

Run completions at marker positions with context stubs injected. Writes the context stubs to a temp directory, configures a ProjectConfig that matche

Look up source locations for a declaration name in `.tix` files. Works for type aliases, module names, and val declarations. Returns an empty slice fo

Get the runtime generation config, if configured.

If `id` is a variable, return a reference to its TypeVariable.

Inference entry point that always produces an InferenceResult, even when errors occur. Errors are collected rather than short-circuiting — SCC groups

Convenience: get the InferenceResult if any inference data is available.

Build a single-node arena containing the given OutputTy and return (arena, root_ref). Used by compare_types tests which need an arena context.

Create a fixture project with inline context stubs. Each context is a `(name, glob_patterns, stubs_content)` tuple. Stubs are written to `stubs/{name

Remove redundant negations from an intersection. When the intersection contains a positive type `T` with a known constructor and `Neg(S)` where `T` an

Rename a symbol at a given position.

Resolve context args for a file based on `tix.toml` context definitions. When a context has a single stub entry, the returned `Arc` shares the cached

Factor shared members from an intersection of unions using the distributive law: `(A|C) & (B|C) = C | (A&B)`. When intersection members are unions sh

Get semantic tokens for a source string. Returns the raw tokens with absolute positions (not delta-encoded) for easier assertions.

Helper: create a FileSignature from an OutputTy value.

Helper to build a sub-package-set entry with children.

Helper: create an AnalysisState with multiple files and query workspace symbols.

Remove tautological pairs from a union: `T ∨ ¬T` = ⊤. When both a type and its negation appear, both are dropped since their union is the top type and

DSU representative for a TyId. Used at every `OutputTy::TyVar` emission site and when tracking polarity / cooccurrence membership.

Expand the `[project] includes` glob patterns into concrete file paths. Patterns are relative to `config_dir` (the directory containing tix.toml). Re

Helper: get signature help at a byte offset.

Convert a file:// URI to a PathBuf, canonicalizing to resolve symlinks and `..` components. This ensures all downstream caches (snapshots, pending_tex

Absorb subsumed attrsets in a union. In a union `A | B`, open attrset A subsumes open attrset B when: - Both are open - A has no dyn_ty (or A.dyn_ty =

Generate a random primitive value literal.

Build inference layers preserving SCC grouping. Like `build_file_layers`, but each layer contains a list of `SccGroup`s rather than a flat file list.

Send a full-text change for a file. Also writes the new text to disk so that `markers()` reads the updated content.

Extract the parameter type from a function type.

Find the ExprId of the first `Expr::Reference` whose name string matches `text`.

Generate the tix.toml content from classified files.

Intern a ParsedTy with fresh type variables for each free generic var and alias resolution for Reference vars. Each call produces an independent "inst

Read and parse a `tix.toml` file.

Convenience: emit `@source` for an optional `NixPosition`, pushing to lines if matched.

Convert an option tree (BTreeMap from the JSON) to a .tix attrset type string. When `emit_docs` is true, option descriptions are emitted as `##` doc c

Construct a `DiagTy` for a primitive type, for use in test assertions. `DiagTy::PartialEq` compares by display string, so two `DiagTy` values wrappin

------------------------------------------------------------------ Helper: create a registry with a stub file on disk --------------------------------

Resolve import types using a caller-provided lookup function. For each scanned import target path: 1. Records navigation targets (for goto-def) regar

Unwrap Named wrappers to get at the structural type.

Analyze a condition expression to extract type narrowing information. Returns a default (empty) `NarrowInfo` if the condition doesn't match any recog

Returns true if any node in this type tree matches `pred`. Short-circuits on first hit. Uses a visited set for DAG safety.

Build a Nix list literal from a slice of module sources. Empty slice returns `"[ ]"`.

Clear all cached state (used on registry reload).

Compact fully-determined variables in the range `[slots_before..len)`. A variable is "pinned" when the same concrete TyId appears in both its lower_b

Discover `.nix` files to check under `root`. If `[project] includes` globs are configured, only files matching those patterns are returned (via `reso

Extract the type alias name from an OutputTy, if it's a Named type.

Like `generate_tix_file` but with explicit doc comment control.

Helper: run partial inference (tolerates errors) and look up a name's type.

Try to produce hover information for the given cursor position.

Convert import resolution errors into `TixDiagnostic`s for rendering in CLI or LSP. Each `ImportError` becomes a warning-level diagnostic attached to

Parse a `.tix` source string as context stubs, loading any type aliases into `self.aliases` (so they can be referenced by val declarations) and return

Wrap a bare `InferenceError` with the current expression location.

Helper: create an OutputTy::Neg with an arena-interned inner.

Record the import dependencies for a file. Replaces any previous entries.

Resolve through Extern layers: if the root type is `Extern(owned)`, return a RootTy pointing into the external arena. Otherwise return self. This lets

Resolve import types from a pre-populated stubs HashMap. Thin wrapper around `resolve_import_types` for backward compatibility with code that has a `