rpg_source.zig: read the other SORTA and %LOOKUP forms (starts, counts, search values, element types, %LOOKUPGT, GE, LT and LE) #800

Manually merged
binjovi-bot merged 3 commits from lsrt2 into trunk 2026-11-14 10:39:20 +00:00
Owner

rpg_source.zig: read the other SORTA and %LOOKUP forms (starts, counts, search values, element types, %LOOKUPGT, GE, LT and LE)

Round two of lane lsrt, stacked on round one (docs/changes/lsrt.md). The 24 captures of the request
requests/lsrt/sorta2 (all public) measure what round one refused. The units of rpg_sorta.zig and
rpg_lookup.zig read them with a red test each, and the ordered lookups have a module of their own,
rpg_lookup_ordered.zig. A shape that differs in any operation or operand still reads nothing and the statement
keeps its failure.

What changed in the reader

  • rpg_unit_pattern.zig: a family has a gap, X NAME: one to twelve operations of a value expression that leave
    one value (the measured loads, decimal add and subtract, conversions). The unit keeps them before its
    operation, so the statement reader writes s + 1 and n - 1 itself. The unit proves its own temporaries
    (every 35 T) and labels (every 15 L) by the pattern, not by a list, and no gap names a temporary of the unit.
  • rpg_sorta.zig: %SUBARR(a: s: n) (two range checks), a literal start of 2 (the start is 1 to the
    dimension, no longer only 1), a count that the statement computed (n - 1), the helper of a zoned array
    (84 D 1 after each load), the integer, character (descending) and packed(7:2) arrays, and the whole-array
    tag 113 TG 2 as a slot (6 packed(5), 7 character, 9 integer, 11 packed(7:2), 12 zoned).
  • rpg_lookup.zig: the start is a field or an expression (the gap) or a literal (27 KS; 75 8; 75 4; 35 TS, no
    check), the count a field or a literal (27 KC; 76 8; 35 TX, checked 0 to the elements left), the search value a
    constant, a field (29 SV 0 TT2; 35 TV) or an element, and the array a packed, character (only the
    two-argument form with a field search value is measured), zoned (84 D 1 after the load, two arguments and
    a constant) or integer one (75 8, the same). An element of a variable index (the element
    unit of rpg_array_element.zig left .element_address) may be of another array; one of a constant index is of
    the array that is searched. Twelve combinations are measured, written in variants; the others do not read.
  • rpg_lookup_ordered.zig: %LOOKUPGT, GE, LT and LE of an array that the program declares ascending, with a
    constant search value, as four texts of about a hundred operations that differ in six places (below).
  • rpg_sort_value.zig reads the new operands, writes %LOOKUPGT(...) and the others, and tells the emitter that
    the array is ascending.

Emitter edits (the only edits of rpg_source*.zig): rpg_source.zig lists %LOOKUPGT, GE, LT and LE as
built-in functions (one line); rpg_facts.zig gives array_element_v1 the flag ascending, and
rpg_source_decl_emit.zig keeps it when two facts name one array and writes ascend after dim(n)
(dcl-s d packed(5:0) dim(10) ascend;; ten lines). Without the keyword the program that the emit writes does
not compile: %LOOKUPGT needs a sequenced array.

Measured (SC-ILE/EXPERIMENTS lsrt-*, statement 13 or 14; a packed(5) dim(10))

case change from round one read as
sorta-subarr-sn 29 S ...; start check; 27 ONE; 52; 75 4; 35 S0; then the count check of %SUBARR(a:1:n) sorta %SUBARR(a: s: n);
sorta-subarr-2n, -2lit the start constant is 2 (27 ST; 75 8; 27 ONE; 52), the rest as the count field and the constants %SUBARR(a: 2: n), (a: 2: 3)
sorta-subarr-expr 29 N 0 T; 27 K; 60 6 0 0 first, then 27 ST; 75 8; 5; 5; 27 ONE; 52; 75 4; 35 S0; 61 6 0 0; 87 8; and the count check %SUBARR(a: 1: n - 1)
sorta-char-desc the whole-array form, tag 7, element type char(5), comparison 10 sorta(d) c;
sorta-zoned the helper has 84 5 1 after each of its two loads (91 operations); the element type is zoned(5), tag 12 sorta z;
sorta-int, sorta-dec2 the helper is the packed one over int(10) (32 A 0 2) and packed(7) (32 A 0 13); tags 9 and 11 sorta(d) k; sorta q;
lookup-var-2, -var-3 the search value is 29 SV 0 TT2; 35 TV (no rescale, TT2 is the element type) %LOOKUP(n: a), (n: a: s)
lookup-lit-start 27 KS; 75 8; 75 4; 35 TS; 27 DIM; 35 TE; (no check) %LOOKUP(4: a: 3)
lookup-lit-count the literal start, then 27 DIM; 27 TS; 52; 27 ONE; 78 4; 47; 35 TE; 27 KC; 76 8; 35 TX; checked 0 to TE and TE = TS + KC - 1 %LOOKUP(4: a: 2: 3)
lookup-expr-start 29 S 0 TT; 27 K; 54 6 0 0 before 35 TQ: the start temporary has six digits (86 6) and is not the search temporary %LOOKUP(4: a: s + 1)
lookup-elem-2, -elem-4 the element a(2) addressed before the unit (34 A 0; 27 OFF; 62), two and four arguments %LOOKUP(a(2): a), (a(2): a: s: n)
lookup-elemvar-same, -other 34 A 0; 29 N 0 T; 87 4; 75 4; 77 4; 27 ONE; 52; 27 K; 138; 78 4; 65 W before the unit (one operation fewer than the bounds-checked form of rpg_array_element.zig) %LOOKUP(a(i): a: s), (a(i): b: s)
lookup-char field search value over c char(5) dim(10), the compare is 7 %LOOKUP(key: c)
lookup-zoned, lookup-int zoned: 84 5 1 after the load, constant 27 KV; 61 5 0 0; integer: 75 8 after the load, constant 27 KV; 75 8; 35 TV %LOOKUP(4: z), (4: k)
lookupgt, ge, lt, le a binary search of the array (below) %LOOKUPGT(4: d) and the others

The ordered lookups search LO to HI (the middle (LO + HI [+ 1]) / 2 is 27 K1; 69, a shift by one), then scan
from the element found. The four texts differ in three places: GT and GE add one to LO + HI (27 ONE; 47), LT and
LE do not; the first scan after the search compares 11 ... 12 and steps up (47) for GT and GE, and compares
9 ... 10 and steps down (52) for LT and LE; the second scan ends with 27 Z2; 35 MID (not found) for GT
and LT, and with 27 MID; 27 ONE; 47; 35 MID (the equal element) for GE and LE. Each is proved by its own text;
the function of a read is the text that matched, and the four captures are the four sources.

Effect

All 24 captures read their statement 13 or 14 (before, ? unresolved statement); none of the 24 emits is free of
failure lines, because the probes' other statements are other work. Development programs (reported as fit, no rule or test holds
their text): p3 0 failure lines before and after; p4 1 to 0 (its %LOOKUP of an element of another array at a
variable index, the one line round one left, is lookup-elemvar-other).

Fix of the declaration of an array (rpg_source_decl_emit.zig, rpg_source.zig): an array of packed or zoned
elements has the digits of its elements from its statements and its decimal positions only when a statement proves
them. The declaration of sorta-dec2 was packed(7:0) dim(10) for packed(7:2), with no marker. It now carries
// SOURCERER-TODO decimal_positions: not proved, 0 assumed, as a field does (the same condition: no scale
proved, no literal scale). The array is marked but not counted in assumed and does not make the unused fields
undeclared: the one literal that proves the positions of a field still proves those of an array (lr1-lv:
packed(15:2) dim(50), unmarked, as before). Arrays of integer, character and float elements are not marked.
The emits of p3 and p4 change by this (the two arrays dim(2000) carry the marker; placeholders 2 to 4 and 1 to 3,
failure lines and emitted statements unchanged), and so do 31 of the 36 captures that I emitted (the 34 of the
two batteries and p3 and p4; the five that stay are the arrays of integer and character elements: lookup-char, lookup-int,
sorta-char, sorta-char-desc and sorta-int); emit-diff.sh between the two builds over the 888 public twins: worse [], failures
1014 to 1014, emitted 8602 to 8602, clean 593 to 593. Eight tests of other lanes asserted ; and a newline after
an array declaration (rpg_decimal_for_test, rpg_array_inz_test, rpg_long_value_test, rpg_num_elem_test):
they now stop at the ;.

The request requests/lsrt/sorta3 holds 12 more shapes (the ordered lookups with a start, a field search value and
a DESCEND array; a field search value with a start and a count; an expression count; a character constant; a zoned
field; an element of an integer array; SORTA(D) with %SUBARR(a:s:n); %SUBARR(a:2:n - 1); float and unsigned
arrays). docs/OPERATIONS.md is regenerated (ops-legend.sh --write).

Probes adopted (matrix rows, none host-matching yet; each keeps the failure lines of statements 9, 10 and 14 or
15 of the probe): lsrt-sorta-subarr-sn, -2n, -2lit, -expr, lsrt-sorta-char-desc, -zoned, -int, -dec2, lsrt-lookup-var-2,
-var-3, -lit-start, -lit-count, -expr-start, -elem-2, -elem-4, -elemvar-same, -elemvar-other, -char, -zoned, -int,
lsrt-lookupgt, -lookupge, -lookuplt, -lookuple.

Gate

lsrt-lookup-elemvar-other base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2
lsrt-lookup-elemvar-same base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2
lsrt-lookup-expr-start base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2
lsrt-lookup-int base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2
lsrt-lookup-lit-count base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2
lsrt-lookup-lit-start base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2
lsrt-lookup-var-2 base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2
lsrt-lookup-var-3 base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2
lsrt-lookup-zoned base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2
lsrt-lookupge base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2
lsrt-lookupgt base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2
lsrt-lookuple base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2
lsrt-lookuplt base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2
lsrt-sorta-char-desc base=[8,4,4] head=[8,5,3] CHANGED fail-lines=3
lsrt-sorta-dec2 base=[8,4,4] head=[8,5,3] CHANGED fail-lines=3
lsrt-sorta-int base=[8,4,4] head=[8,5,3] CHANGED fail-lines=3
lsrt-sorta-subarr-2lit base=[8,4,4] head=[8,5,3] CHANGED fail-lines=3
lsrt-sorta-subarr-2n base=[8,4,4] head=[8,5,3] CHANGED fail-lines=3
lsrt-sorta-subarr-expr base=[8,4,4] head=[8,5,3] CHANGED fail-lines=3
lsrt-sorta-subarr-sn base=[8,4,4] head=[8,5,3] CHANGED fail-lines=3
lsrt-sorta-zoned base=[8,4,4] head=[8,5,3] CHANGED fail-lines=3
capture-emit-diff: 45 cases, 35 changed, 3 with no failure line in the head emit
== e. source agreement (agree)
suspect        base=78 head=78
conflict       base=0 head=0
params_wrong   base=15 head=15
decl_missing   base=81 head=81
decl_extra     base=25 head=25
type_unmarked  base=80 head=56
gate: PASS

Host round trips on the build before the scale-marker commit: dev5 p3 and p4 compile (different; the round trip lacks the capture LICOPT until loop #118).

# rpg_source.zig: read the other SORTA and %LOOKUP forms (starts, counts, search values, element types, %LOOKUPGT, GE, LT and LE) Round two of lane lsrt, stacked on round one (`docs/changes/lsrt.md`). The 24 captures of the request `requests/lsrt/sorta2` (all public) measure what round one refused. The units of `rpg_sorta.zig` and `rpg_lookup.zig` read them with a red test each, and the ordered lookups have a module of their own, `rpg_lookup_ordered.zig`. A shape that differs in any operation or operand still reads nothing and the statement keeps its failure. ## What changed in the reader - `rpg_unit_pattern.zig`: a family has a gap, `X NAME`: one to twelve operations of a value expression that leave one value (the measured loads, decimal add and subtract, conversions). The unit keeps them before its operation, so the statement reader writes `s + 1` and `n - 1` itself. The unit proves its own temporaries (every `35 T`) and labels (every `15 L`) by the pattern, not by a list, and no gap names a temporary of the unit. - `rpg_sorta.zig`: `%SUBARR(a: s: n)` (two range checks), a literal start of 2 (the start is 1 to the dimension, no longer only 1), a count that the statement computed (`n - 1`), the helper of a zoned array (`84 D 1` after each load), the integer, character (descending) and packed(7:2) arrays, and the whole-array tag `113 TG 2` as a slot (6 packed(5), 7 character, 9 integer, 11 packed(7:2), 12 zoned). - `rpg_lookup.zig`: the start is a field or an expression (the gap) or a literal (`27 KS; 75 8; 75 4; 35 TS`, no check), the count a field or a literal (`27 KC; 76 8; 35 TX`, checked 0 to the elements left), the search value a constant, a field (`29 SV 0 TT2; 35 TV`) or an element, and the array a packed, character (only the two-argument form with a field search value is measured), zoned (`84 D 1` after the load, two arguments and a constant) or integer one (`75 8`, the same). An element of a variable index (the element unit of `rpg_array_element.zig` left `.element_address`) may be of another array; one of a constant index is of the array that is searched. Twelve combinations are measured, written in `variants`; the others do not read. - `rpg_lookup_ordered.zig`: `%LOOKUPGT`, `GE`, `LT` and `LE` of an array that the program declares ascending, with a constant search value, as four texts of about a hundred operations that differ in six places (below). - `rpg_sort_value.zig` reads the new operands, writes `%LOOKUPGT(...)` and the others, and tells the emitter that the array is ascending. Emitter edits (the only edits of `rpg_source*.zig`): `rpg_source.zig` lists `%LOOKUPGT`, `GE`, `LT` and `LE` as built-in functions (one line); `rpg_facts.zig` gives `array_element_v1` the flag `ascending`, and `rpg_source_decl_emit.zig` keeps it when two facts name one array and writes ` ascend` after `dim(n)` (`dcl-s d packed(5:0) dim(10) ascend;`; ten lines). Without the keyword the program that the emit writes does not compile: `%LOOKUPGT` needs a sequenced array. ## Measured (SC-ILE/EXPERIMENTS lsrt-*, statement 13 or 14; a packed(5) dim(10)) | case | change from round one | read as | |---|---|---| | sorta-subarr-sn | `29 S ...; start check; 27 ONE; 52; 75 4; 35 S0;` then the count check of `%SUBARR(a:1:n)` | `sorta %SUBARR(a: s: n);` | | sorta-subarr-2n, -2lit | the start constant is 2 (`27 ST; 75 8; 27 ONE; 52`), the rest as the count field and the constants | `%SUBARR(a: 2: n)`, `(a: 2: 3)` | | sorta-subarr-expr | `29 N 0 T; 27 K; 60 6 0 0` first, then `27 ST; 75 8; 5; 5; 27 ONE; 52; 75 4; 35 S0; 61 6 0 0; 87 8;` and the count check | `%SUBARR(a: 1: n - 1)` | | sorta-char-desc | the whole-array form, tag 7, element type char(5), comparison `10` | `sorta(d) c;` | | sorta-zoned | the helper has `84 5 1` after each of its two loads (91 operations); the element type is zoned(5), tag 12 | `sorta z;` | | sorta-int, sorta-dec2 | the helper is the packed one over `int(10)` (`32 A 0 2`) and packed(7) (`32 A 0 13`); tags 9 and 11 | `sorta(d) k;` `sorta q;` | | lookup-var-2, -var-3 | the search value is `29 SV 0 TT2; 35 TV` (no rescale, TT2 is the element type) | `%LOOKUP(n: a)`, `(n: a: s)` | | lookup-lit-start | `27 KS; 75 8; 75 4; 35 TS; 27 DIM; 35 TE;` (no check) | `%LOOKUP(4: a: 3)` | | lookup-lit-count | the literal start, then `27 DIM; 27 TS; 52; 27 ONE; 78 4; 47; 35 TE; 27 KC; 76 8; 35 TX;` checked 0 to TE and `TE = TS + KC - 1` | `%LOOKUP(4: a: 2: 3)` | | lookup-expr-start | `29 S 0 TT; 27 K; 54 6 0 0` before `35 TQ`: the start temporary has six digits (`86 6`) and is not the search temporary | `%LOOKUP(4: a: s + 1)` | | lookup-elem-2, -elem-4 | the element `a(2)` addressed before the unit (`34 A 0; 27 OFF; 62`), two and four arguments | `%LOOKUP(a(2): a)`, `(a(2): a: s: n)` | | lookup-elemvar-same, -other | `34 A 0; 29 N 0 T; 87 4; 75 4; 77 4; 27 ONE; 52; 27 K; 138; 78 4; 65 W` before the unit (one operation fewer than the bounds-checked form of `rpg_array_element.zig`) | `%LOOKUP(a(i): a: s)`, `(a(i): b: s)` | | lookup-char | field search value over `c char(5) dim(10)`, the compare is `7` | `%LOOKUP(key: c)` | | lookup-zoned, lookup-int | zoned: `84 5 1` after the load, constant `27 KV; 61 5 0 0`; integer: `75 8` after the load, constant `27 KV; 75 8; 35 TV` | `%LOOKUP(4: z)`, `(4: k)` | | lookupgt, ge, lt, le | a binary search of the array (below) | `%LOOKUPGT(4: d)` and the others | The ordered lookups search LO to HI (the middle `(LO + HI [+ 1]) / 2` is `27 K1; 69`, a shift by one), then scan from the element found. The four texts differ in three places: GT and GE add one to LO + HI (`27 ONE; 47`), LT and LE do not; the first scan after the search compares `11 ... 12` and steps up (`47`) for GT and GE, and compares `9 ... 10` and steps down (`52`) for LT and LE; the second scan ends with `27 Z2; 35 MID` (not found) for GT and LT, and with `27 MID; 27 ONE; 47; 35 MID` (the equal element) for GE and LE. Each is proved by its own text; the function of a read is the text that matched, and the four captures are the four sources. ## Effect All 24 captures read their statement 13 or 14 (before, `? unresolved statement`); none of the 24 emits is free of failure lines, because the probes' other statements are other work. Development programs (reported as fit, no rule or test holds their text): p3 0 failure lines before and after; p4 1 to 0 (its `%LOOKUP` of an element of another array at a variable index, the one line round one left, is lookup-elemvar-other). Fix of the declaration of an array (`rpg_source_decl_emit.zig`, `rpg_source.zig`): an array of packed or zoned elements has the digits of its elements from its statements and its decimal positions only when a statement proves them. The declaration of sorta-dec2 was `packed(7:0) dim(10)` for `packed(7:2)`, with no marker. It now carries `// SOURCERER-TODO decimal_positions: not proved, 0 assumed`, as a field does (the same condition: no scale proved, no literal scale). The array is marked but not counted in `assumed` and does not make the unused fields undeclared: the one literal that proves the positions of a field still proves those of an array (`lr1-lv`: `packed(15:2) dim(50)`, unmarked, as before). Arrays of integer, character and float elements are not marked. The emits of p3 and p4 change by this (the two arrays `dim(2000)` carry the marker; placeholders 2 to 4 and 1 to 3, failure lines and emitted statements unchanged), and so do 31 of the 36 captures that I emitted (the 34 of the two batteries and p3 and p4; the five that stay are the arrays of integer and character elements: lookup-char, lookup-int, sorta-char, sorta-char-desc and sorta-int); `emit-diff.sh` between the two builds over the 888 public twins: worse [], failures 1014 to 1014, emitted 8602 to 8602, clean 593 to 593. Eight tests of other lanes asserted `;` and a newline after an array declaration (`rpg_decimal_for_test`, `rpg_array_inz_test`, `rpg_long_value_test`, `rpg_num_elem_test`): they now stop at the `;`. The request `requests/lsrt/sorta3` holds 12 more shapes (the ordered lookups with a start, a field search value and a DESCEND array; a field search value with a start and a count; an expression count; a character constant; a zoned field; an element of an integer array; SORTA(D) with `%SUBARR(a:s:n)`; `%SUBARR(a:2:n - 1)`; float and unsigned arrays). docs/OPERATIONS.md is regenerated (`ops-legend.sh --write`). Probes adopted (matrix rows, none host-matching yet; each keeps the failure lines of statements 9, 10 and 14 or 15 of the probe): lsrt-sorta-subarr-sn, -2n, -2lit, -expr, lsrt-sorta-char-desc, -zoned, -int, -dec2, lsrt-lookup-var-2, -var-3, -lit-start, -lit-count, -expr-start, -elem-2, -elem-4, -elemvar-same, -elemvar-other, -char, -zoned, -int, lsrt-lookupgt, -lookupge, -lookuplt, -lookuple. ## Gate ``` lsrt-lookup-elemvar-other base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2 lsrt-lookup-elemvar-same base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2 lsrt-lookup-expr-start base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2 lsrt-lookup-int base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2 lsrt-lookup-lit-count base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2 lsrt-lookup-lit-start base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2 lsrt-lookup-var-2 base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2 lsrt-lookup-var-3 base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2 lsrt-lookup-zoned base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2 lsrt-lookupge base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2 lsrt-lookupgt base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2 lsrt-lookuple base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2 lsrt-lookuplt base=[8,5,3] head=[8,6,2] CHANGED fail-lines=2 lsrt-sorta-char-desc base=[8,4,4] head=[8,5,3] CHANGED fail-lines=3 lsrt-sorta-dec2 base=[8,4,4] head=[8,5,3] CHANGED fail-lines=3 lsrt-sorta-int base=[8,4,4] head=[8,5,3] CHANGED fail-lines=3 lsrt-sorta-subarr-2lit base=[8,4,4] head=[8,5,3] CHANGED fail-lines=3 lsrt-sorta-subarr-2n base=[8,4,4] head=[8,5,3] CHANGED fail-lines=3 lsrt-sorta-subarr-expr base=[8,4,4] head=[8,5,3] CHANGED fail-lines=3 lsrt-sorta-subarr-sn base=[8,4,4] head=[8,5,3] CHANGED fail-lines=3 lsrt-sorta-zoned base=[8,4,4] head=[8,5,3] CHANGED fail-lines=3 capture-emit-diff: 45 cases, 35 changed, 3 with no failure line in the head emit == e. source agreement (agree) suspect base=78 head=78 conflict base=0 head=0 params_wrong base=15 head=15 decl_missing base=81 head=81 decl_extra base=25 head=25 type_unmarked base=80 head=56 gate: PASS ``` Host round trips on the build before the scale-marker commit: dev5 p3 and p4 compile (different; the round trip lacks the capture LICOPT until loop #118).
A pattern may hold a gap, a value expression that the statement computed
(%LOOKUP start s + 1, %SUBARR count n - 1). SORTA reads %SUBARR(a:s:n),
a literal start of 2, a count expression, and zoned, integer, character
(descending) and packed(7:2) arrays. %LOOKUP reads a literal or expression
start, a literal count, a field or an element at a variable index of another
array as the search value, character, zoned and integer arrays, and the four
ordered searches of an ascending array. The emitter writes ascend for them.
An array declared from array_element_v1 with packed or zoned elements
assumed 0 positions and said nothing (sorta-dec2: packed(7:0) for
packed(7:2)). Its declaration now carries the SOURCERER-TODO
decimal_positions marker under the condition of a field. The array is not
counted as an assumed field and does not drop the unused fields, so the one
literal that proves a field's positions still proves the array's.
sean force-pushed lsrt2 from 48c84fe9d3 to 97f7ff31cb
All checks were successful
binjovi/ci Binjovi completed the frozen plan
2026-11-14 10:23:48 +00:00
Compare
binjovi-bot manually merged commit b67193fb1a into trunk 2026-11-14 10:39:19 +00:00
Sign in to join this conversation.
No reviewers
No labels
No milestone
No project
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
sean/sourcerer!800
No description provided.