Module Tolk.Uop_weak

commit_weak_consts u dt is u with each of its sources that is a weak constant converted to dt (Ops.ccast), and u if dt is None. A rewrite that builds a node from weak literals next to an operand of type dt states their width with it.

pm_commit_weak commits weak sources whose width something states:

• a broadcastable node (Op.Set.broadcastable) with a weak source, whose sources' least upper type dt is committed, converts its weak sources to dt. A weak constant stays a weak literal, its value converted to dt (Dtype.const), when the node's type does not depend on it: the other sources already derive a committed type for the node. A shift's count is a number of bits, so it never wraps at dt: a count of Dtype.bitsize dt or more shifts every bit out, so a weak count saturates at that width. An expression whose bounds dt does not hold saturates at its own committed type (Ops.commit_dtype) and then converts to dt. An expression whose bounds no 64-bit integer holds (Ops.fits_no_int) is the width if its bounds are all past the width, and otherwise raises Invalid_argument when the rule runs: wrapped, it would shift by the wrong number. An integer power's exponent is a number too: it stays weak, its value whole;
• a Op.t.Store of a weak value converts it to the destination's type;
• a cast to a committed type dt over a weak arithmetic node u of dt's kind commits u's weak sources at the least upper type of dt, u's committed type and each weak source's committed type, a shift's count and an integer power's exponent apart, and casts the result to dt. Where that type is a float, as it is for a 64-bit unsigned dt over a signed width, they commit at Dtype.t.Int64 instead, or at Dtype.t.Uint64 where one of the committed types is: an integer cast computes in integers.

It runs with every rewrite that can build a weak constant, and must reach its fixed point before pm_lower_weak gives defaults.

pm_lower_weak gives every weak node that nothing committed its default width (Ops.commit_dtype, with Dtype.t.Int32 as the default integer):

• a node's sources lose the weak casts over them, which only restated a width the node restates; a weak integer cast of a boolean or a float is a conversion, and commits to its default instead;
• a weak constant whose consumer derives no committed type from its sources takes its default;
• once no source is a weak expression, a unary, binary, Op.t.Where, Op.t.Range, Op.t.Stack or Op.t.Special node computes at one committed type: for a binary node, the least upper type of its sources and of its own default, and otherwise the type it derives. Its sources are converted to it, and the node is cast back to its own type, which its consumers absorb in turn;
• two stacked weak casts over a committed value are two conversions, each at the default of its kind;
• a weak integer scalar parameter or buffer is stored at its default, cast back to Dtype.t.Weak_int;
• an Op.t.Index or Op.t.Shrink whose index is an Dtype.t.Int64 guarded by a condition, and Ops.invalid elsewhere, indexes through an Dtype.t.Int32 when the storage's greatest index fits one: the values outside the guard are discarded.

pm_cast_const states the width of every constant still weak, at each consumer: a broadcastable consumer that derives a committed type from its sources converts its weak constants to their least upper type, and every remaining bare constant becomes a cast of the literal to its committed type (Ops.cconst), booleans included. Ops.invalid stays bare.