Module Ir.Indexing

discarding_symbols f runs f and then rewinds the symbol counter to where it was: for dry runs whose minted symbols are all discarded (a schedule probe), so they shift no later minted name. Sound only when no symbol f mints outlives it.

Private (gh-ocannl-1624): read and matched freely, built by make_static_symbol or get_static_symbol, and written only through the setters below. The roles (used_as_extent, used_as_slice) are shape-inference state of a caller-retained symbol: after its birth a role is written only by commit_role, which takes shape_writer. The declared range is not inference state; set_static_range writes it.

A static symbol over symbol, holding the role used_as from birth (default: none). A role given at birth is not a write to a symbol anything else holds yet, so it needs no writer -- hand-built IR uses it for a symbolic extent no shape inference claimed.

Re-declares the symbol's range. The analysis caches key on it, so a changed range misses.

A launch parameter's cell as backend linking mints it: UNASSIGNED (gh-ocannl-940), holding a value outside every legal one, which validate_bound_value refuses naming the parameter. A caller assigns it through find_exn bindings sym := v; a caller that means 0 writes 0.

Whether the cell holds a value someone assigned, rather than the one fresh_launch_param left there.

Bind-time validation of one launch-parameter value: refuses an unassigned one (gh-ocannl-940), a negative one, one outside the declared range (below range for an index, up to range inclusive for a symbolic extent) and, unless width64, one past the int32 index width.

validate_bound_value over every parameter, reporting all the unassigned ones in one message first.

set_launch_value ~caller bs sym v validates v (validate_bound_value) and writes it into sym's cell of bs; a symbol bs does not bind is refused, naming caller.

The launch values of a routine that a library entry point compiles and runs on the caller's behalf (gh-ocannl-1629): a fresh cell per symbol, the caller's values written into it (a symbol it does not bind, or given twice, is refused; the values themselves are validated by the run, once lowering has committed the role -- index or extent -- each is validated against), then every parameter left unassigned set to 0 -- unless ranged names its kind (a batch-slice index, a ranged static index, a symbolic extent), which is refused instead, naming each one and its kind and ending with hint: 0 is its first slice or empty extent, the silent default gh-ocannl-940 refuses. Hand the result to copy_launch_values once the routine is linked.

copy_launch_values ~from bs writes into each cell of bs the value from holds for the same symbol; every symbol of bs must be bound by from.

Coalesce repeated symbols, remove zero terms, and use Fixed_idx or Iterator whenever possible. The private payload prevents bypassing this normalization.

Private (gh-ocannl-1573): read and matched freely, written only through the setters below. A solution is reached once: at most one of solved_dim, solved_sym is ever set, and a set field keeps its value. Shape inference is the only writer: the setters take shape_writer, which Shape holds, and its capture references wrap them with the session's accounting (gh-ocannl-1624). The cell is shared, so an Assignments.Embed_dim built before inference observes the solution it later reaches.

A fresh, unsolved reference with the given label.

The capability to write shape-inference state held by this module's records: solve a variable_ref, commit a static symbol's role (gh-ocannl-1624). A process has at most one: the first claim_shape_writer returns it and every later one raises. In a program linking the tensor frontend, Shape claims it as it initializes, so the setters taking it are Shape's alone -- a write through them could not skip the session's accounting (liveness of a rewound reference, the open set, the mutation serial).

Returns the process's shape_writer; raises Utils.User_error when it was already claimed.

Records a concrete solution. Setting the value it already holds is a no-op; a different value, or a reference already solved to a symbol, raises.

Records a symbolic-extent solution, guarded like set_solved_dim.

A reference's solution at a checkpoint, bound to that reference (gh-ocannl-903).

Puts the recorded solution back on its reference -- unsolving it if it was unsolved: a rewind's write, so it takes the writer.

Whether the reference's solution differs from the recorded one: a diagnostic.

Sets the symbol's role flag. Committing the role it holds is a no-op; the other role raises (a binding cannot be validated both inclusively and strictly). Shape calls it only from a successful finish_inference, for the claims Row.claim_symbol_role counted.