An array that a SORTA sorts keeps the name of its helper _QRNI_SORT_A_<name> #804

Manually merged
binjovi-bot merged 1 commit from ldev4 into trunk 2026-11-14 19:45:07 +00:00
Owner

An array that a SORTA sorts keeps the name of its helper _QRNI_SORT_A_<name>

Two development programs whose round trips compile with the same instructions
and the same control flow as the original, and differ in the constant area and
the initialization only (the sizes of both are equal), have one cause: the
helper procedure of SORTA.

The compiler writes a helper _QRNI_SORT_A_<array name> (_QRNI_SORT_D_ for
SORTA(D)) for each array that the source sorts, and the stripped object keeps
its name. The names of the symbols are gone, so the emit called the array
A_00256, and the rebuild named the helper _QRNI_SORT_A_A_00256. The two
procedure names are strings of the object: the constant area and the
initialization differ by them and by nothing else.

rpg_sort_names.zig (new, PURE) reads the helpers of the module and gives the
array of each its name:

  • the body of the helper proves the array (rpg_sorta.sortedBy, new: the same
    four measured bodies as a call, without the call, and the symbol AR of the
    body), and the name proves the direction (rpg_sort_value.arrayNameOf:
    _QRNI_SORT_A_ for an ascending body, _QRNI_SORT_D_ for a descending one);
  • the name is what follows the direction: SORTA q with DCL-S q PACKED(7:2) DIM(10) has the helper _QRNI_SORT_A_Q and the array is declared Q.

The array gets that name when all of these hold, and keeps its placeholder when
one fails (each rule has a test of the emitted text, rpg_sort_names_test.zig):

  • the suffix is an upper case letter, then upper case letters, digits and _,
    at most 30 characters (8 in the fixed and mixed forms: a factor holds 14, and
    the placeholders after a kept name are the name, _ and 5 digits). RPG
    allows 4096 and a source line holds 100, but a name of 100 characters made
    every declaration after it "longer than 100 bytes" (13 failures against the 3
    of lsrt-sorta-subarr-sn, measured with a throwaway test), and 60 characters
    cost none. 30 is a limit of this change, below what was measured; a longer
    name keeps the placeholder;
  • one array has one name: SORTA and SORTA(D) of the same array have the same
    suffix and agree; two different suffixes for one array name neither
    (policy test, no probe sorts one array both ways);
  • one name belongs to one array: two arrays whose helpers have the same suffix
    keep their placeholders (policy test);
  • no other name of the module is the same, in either case: the procedures of
    the module, the imports, the file and record names, the SQL host names and
    every other kept name (probe lsrt-sorta-all, a procedure named words beside a helper
    _QRNI_SORT_A_WORDS);
  • the suffix has not the shape of a generated name (A_00254, V00254,
    A_00253_F10): the placeholders are computed after the kept names;
  • the symbol is declared as a dcl-s array: the emitter has an array_element
    fact for it, the declaration has a dim(, it is no parameter and no based
    field, no data structure proves it (ds_arrays), every part of it that a
    statement names is an element, and its length is the dimension times the
    width;
  • the name sorts, in EBCDIC, between the kept names around it in the order of
    the symbols, and two names of arrays that do not sort as their symbols are
    numbered stay out (neither is kept): rpg_sort_names.inOrder, which takes the
    comparison as names_mod.udatePlace does. The slot of UDATE is not among those
    neighbours: it is placed after this pass, with the new names among the kept
    names, and omitted when it has no place, as it is for a procedure name.

A kept name is an anchor, as a procedure name is (nameSymbols): the compiler
numbers the symbols in the order of their names, and the placeholders around the
name sort between it and the next kept name. So the names near a renamed array
change too. lsrt-sorta-char (SORTA %SUBARR(c: 1: n)) wrote A_00254 for the
array and A_00256 for n; it writes C and C_00256 (the prefix of the next
run is the kept name and _, rpg_source.namePrefix). The names that this
produces are the names of the source on every public probe: A, C, Q,
INTEGER_LIST, ZONED_VALUES.

Deviation from the brief: #, @ and $ are not accepted in the suffix. @ is
a variant character of CCSID 273 and a name with it does not compile
(rpg_source.tagPrefix, calibration K). The placeholders after a kept name start
with that name and _, and A#B_00254 is split at the # by the name check of
the emitter (the name B_00255 names no symbol): the first run of the test
measured 5 failures against the 3 of the probe. $ was not run apart from #;
it is refused with it. Such a name keeps the placeholder until the
prefix and the check handle it; a capture of an array with a # or $ in its
name is the probe that a rule needs.

Out of scope, and why:

  • The array of a qualified data structure or a subfield. No capture sorts one.
    The object has one symbol for the structure and for an array that fills it, so
    the suffix cannot show whether it is ROW#2_X of a structure or a plain array
    of that name; the emitter declares both as a dcl-s array (isStructure
    returns false for an array first). Only what a structure proves is refused
    (ds_arrays, a part that is no element); the case needs a probe that sorts
    ds.arr, and until it exists the mapping is not proved.
  • The fixed and mixed forms: no probe sorts there, so the limit of 8 is a
    reading of the columns and is tested through validName, not through an emit.
  • The refusals of plainArray (a parameter, a based field, a failed
    declaration, an array that a structure proves, a part that is no element, a
    length that is not dimension times width) have no probe: no capture sorts such
    an array. The test of the helper names and of the order is on the policy.
  • Two names that do not sort as their symbols are numbered: neither is kept,
    because the symbol numbers contradict a helper name and the object does not
    say which.

Tests: rpg_sort_names_test.zig (new): the whole array, SORTA(D), %SUBARR,
the other uses of the name and the names after it (lsrt-sorta-all, -desc,
-char, -subarr-n); a helper suffix of another name (TOTALS); a name of 30
characters costs no statement (lsrt-sorta-subarr-sn); the suffixes 1A, a,
_A, 9, A#B, A$B, A@B, #B, a suffix of 31 characters, A_00254,
V00254 and A_00253_F10 refuse; sortedBy of the two directions, of a symbol
that is no procedure, of one outside the module and of a changed comparison;
found with no names, a name of the other direction and a limit below the
name; inOrder for a name between its neighbours, below, above, equal to the
kept name, two out of order, and a drop that exposes a new pair; the suffix equal to the name of
another procedure refuses (and names the array when the other procedure has
another name); the policy on its own for one array with two names, one name for
two arrays, SORTA and SORTA(D) agreeing, a taken name in either case, and the
valid names. rpg_lsrt_test.zig and rpg_lsrt2_test.zig pinned the
placeholders of the 14 SORTA probes: they pin the names of the source now (A,
C, Q, INTEGER_LIST, ZONED_VALUES).

Before and after, the Debug build of this branch against the Debug build of
the ldev3 worktree before this change: the 34 cases of the batteries lsrt-sorta and lsrt-sorta2
change in 14 emits, the 14 that have a SORTA; the 20 %LOOKUP cases are the same
bytes. In all 34 the counts of statements, emitted and failures and the count of
failure and placeholder comment lines are equal. The census is 645 recovered, 0
regressions, 0 newly recovered. The development programs p3 and p4 (a fit
measurement, not evidence of a rule) name their two sorted arrays and every use
of them as the helper does, and the fields after them take the prefix of the
last kept name and _; their emitted and failure counts are equal. Whether the
recompile of either now matches is the host gate of the coordinator.

Gate (host round trips, base = ldev3 build, the code of v0.1.520)

diff -r -x emit.ndjson -x *.receipt.json /Users/someara/data/sourcerer-loop/runs/emitbytes.mTmu6B/base-emit/608-PA1E46920S.rpgle /Users/someara/data/sourcerer-loop/runs/emitbytes.mTmu6B/head-emit/608-PA1E46920S.rpgle
2,6c2,6
< dcl-s A_00254 char(5) dim(10);
< dcl-s A_00255 packed(5:0) inz(3);
< dcl-s A_00256 packed(5:0) inz(6);
< dcl-s A_00257 packed(5:0);
< dcl-s A_00258 packed(5:0) inz(2);
---
> dcl-s C char(5) dim(10);
> dcl-s C_00255 packed(5:0) inz(3);
> dcl-s C_00256 packed(5:0) inz(6);
forms projection differs:
564,577c564,577
< {"twin":"savf/SC-ILE/EXPERIMENTS/lsrt-sorta-all/stripped","object":"PFFE7C692S","status":"done","statements":7,"emitted":4,"failures":3,"lines":16,"form_counts":{"array_element_v1":2,"cycle_body_routine_v1":1,"cycle_end_v1":1,"cycle_return_transfer_v1":1,"direct_branch_v1":1,"emit_dcl_s_v1":6,"emit_endfor_v1":1,"emit_for_v1":1,"emit_free_v1":1,"emit_inlr_v1":1,"emit_sorta_v1":1,"emit_summary_v1":2,"fail_statement_v1":3,"placeholder_decimal_positions_v1":1,"static_initialization_v1":1},"text_sha256":"4a9b4eb319a3f381207f9d47d06416104f911633a0bab0ad7945aa4ba30ec93d"}
< {"twin":"savf/SC-ILE/EXPERIMENTS/lsrt-sorta-char-desc/stripped","object":"PA1E46920S","status":"done","statements":8,"emitted":5,"failures":3,"lines":16,"form_counts":{"array_element_v1":2,"cycle_body_routine_v1":1,"cycle_end_v1":1,"cycle_return_transfer_v1":1,"direct_branch_v1":1,"emit_assign_field_v1":1,"emit_dcl_s_v1":5,"emit_endfor_v1":1,"emit_for_v1":1,"emit_free_v1":1,"emit_inlr_v1":1,"emit_sorta_v1":1,"emit_summary_v1":1,"fail_statement_v1":3,"layout_blank_v1":1,"static_initialization_v1":1},"text_sha256":"3854cd9faafba1e4c541dfde57cd30a2e7fe39a4f81a4b099cc68435d37a51d7"}
== d. captures (capture-emit-diff)
p3 base=[18,18,0] head=[18,18,0] CHANGED fail-lines=0
p4 base=[22,22,0] head=[22,22,0] CHANGED fail-lines=0
lsrt-sorta-all base=[7,4,3] head=[7,4,3] CHANGED fail-lines=3
lsrt-sorta-char base=[7,4,3] head=[7,4,3] CHANGED fail-lines=3
lsrt-sorta-desc base=[7,4,3] head=[7,4,3] CHANGED fail-lines=3
lsrt-sorta-subarr-lit base=[7,4,3] head=[7,4,3] CHANGED fail-lines=3
lsrt-sorta-subarr-n base=[7,4,3] head=[7,4,3] CHANGED fail-lines=3
lsrt-sorta-subarr-s base=[7,4,3] head=[7,4,3] CHANGED fail-lines=3
lsrt-sorta-char-desc base=[8,5,3] head=[8,5,3] CHANGED fail-lines=3
lsrt-sorta-dec2 base=[8,5,3] head=[8,5,3] CHANGED fail-lines=3
lsrt-sorta-int base=[8,5,3] head=[8,5,3] CHANGED fail-lines=3
lsrt-sorta-subarr-2lit base=[8,5,3] head=[8,5,3] CHANGED fail-lines=3
lsrt-sorta-subarr-2n base=[8,5,3] head=[8,5,3] CHANGED fail-lines=3
lsrt-sorta-subarr-expr base=[8,5,3] head=[8,5,3] CHANGED fail-lines=3
lsrt-sorta-subarr-sn base=[8,5,3] head=[8,5,3] CHANGED fail-lines=3
lsrt-sorta-zoned base=[8,5,3] head=[8,5,3] CHANGED fail-lines=3
capture-emit-diff: 45 cases, 16 changed, 3 with no failure line in the head emit
== e. source agreement (agree)
suspect        base=76 head=76
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=56 head=56
== f. host round trips (both binaries)
cases to round-trip: 3
dev5/p3                                            base=different head=match
dev5/p4                                            base=different head=match
gate: PASS
# An array that a SORTA sorts keeps the name of its helper `_QRNI_SORT_A_<name>` Two development programs whose round trips compile with the same instructions and the same control flow as the original, and differ in the constant area and the initialization only (the sizes of both are equal), have one cause: the helper procedure of `SORTA`. The compiler writes a helper `_QRNI_SORT_A_<array name>` (`_QRNI_SORT_D_` for `SORTA(D)`) for each array that the source sorts, and the stripped object keeps its name. The names of the symbols are gone, so the emit called the array `A_00256`, and the rebuild named the helper `_QRNI_SORT_A_A_00256`. The two procedure names are strings of the object: the constant area and the initialization differ by them and by nothing else. `rpg_sort_names.zig` (new, PURE) reads the helpers of the module and gives the array of each its name: - the body of the helper proves the array (`rpg_sorta.sortedBy`, new: the same four measured bodies as a call, without the call, and the symbol `AR` of the body), and the name proves the direction (`rpg_sort_value.arrayNameOf`: `_QRNI_SORT_A_` for an ascending body, `_QRNI_SORT_D_` for a descending one); - the name is what follows the direction: `SORTA q` with `DCL-S q PACKED(7:2) DIM(10)` has the helper `_QRNI_SORT_A_Q` and the array is declared `Q`. The array gets that name when all of these hold, and keeps its placeholder when one fails (each rule has a test of the emitted text, `rpg_sort_names_test.zig`): - the suffix is an upper case letter, then upper case letters, digits and `_`, at most 30 characters (8 in the fixed and mixed forms: a factor holds 14, and the placeholders after a kept name are the name, `_` and 5 digits). RPG allows 4096 and a source line holds 100, but a name of 100 characters made every declaration after it "longer than 100 bytes" (13 failures against the 3 of lsrt-sorta-subarr-sn, measured with a throwaway test), and 60 characters cost none. 30 is a limit of this change, below what was measured; a longer name keeps the placeholder; - one array has one name: `SORTA` and `SORTA(D)` of the same array have the same suffix and agree; two different suffixes for one array name neither (policy test, no probe sorts one array both ways); - one name belongs to one array: two arrays whose helpers have the same suffix keep their placeholders (policy test); - no other name of the module is the same, in either case: the procedures of the module, the imports, the file and record names, the SQL host names and every other kept name (probe lsrt-sorta-all, a procedure named `words` beside a helper `_QRNI_SORT_A_WORDS`); - the suffix has not the shape of a generated name (`A_00254`, `V00254`, `A_00253_F10`): the placeholders are computed after the kept names; - the symbol is declared as a `dcl-s` array: the emitter has an `array_element` fact for it, the declaration has a `dim(`, it is no parameter and no based field, no data structure proves it (`ds_arrays`), every part of it that a statement names is an element, and its length is the dimension times the width; - the name sorts, in EBCDIC, between the kept names around it in the order of the symbols, and two names of arrays that do not sort as their symbols are numbered stay out (neither is kept): `rpg_sort_names.inOrder`, which takes the comparison as `names_mod.udatePlace` does. The slot of UDATE is not among those neighbours: it is placed after this pass, with the new names among the kept names, and omitted when it has no place, as it is for a procedure name. A kept name is an anchor, as a procedure name is (`nameSymbols`): the compiler numbers the symbols in the order of their names, and the placeholders around the name sort between it and the next kept name. So the names near a renamed array change too. lsrt-sorta-char (`SORTA %SUBARR(c: 1: n)`) wrote `A_00254` for the array and `A_00256` for `n`; it writes `C` and `C_00256` (the prefix of the next run is the kept name and `_`, `rpg_source.namePrefix`). The names that this produces are the names of the source on every public probe: `A`, `C`, `Q`, `INTEGER_LIST`, `ZONED_VALUES`. Deviation from the brief: `#`, `@` and `$` are not accepted in the suffix. `@` is a variant character of CCSID 273 and a name with it does not compile (`rpg_source.tagPrefix`, calibration K). The placeholders after a kept name start with that name and `_`, and `A#B_00254` is split at the `#` by the name check of the emitter (`the name B_00255 names no symbol`): the first run of the test measured 5 failures against the 3 of the probe. `$` was not run apart from `#`; it is refused with it. Such a name keeps the placeholder until the prefix and the check handle it; a capture of an array with a `#` or `$` in its name is the probe that a rule needs. Out of scope, and why: - The array of a qualified data structure or a subfield. No capture sorts one. The object has one symbol for the structure and for an array that fills it, so the suffix cannot show whether it is `ROW#2_X` of a structure or a plain array of that name; the emitter declares both as a `dcl-s` array (`isStructure` returns false for an array first). Only what a structure proves is refused (`ds_arrays`, a part that is no element); the case needs a probe that sorts `ds.arr`, and until it exists the mapping is not proved. - The fixed and mixed forms: no probe sorts there, so the limit of 8 is a reading of the columns and is tested through `validName`, not through an emit. - The refusals of `plainArray` (a parameter, a based field, a failed declaration, an array that a structure proves, a part that is no element, a length that is not dimension times width) have no probe: no capture sorts such an array. The test of the helper names and of the order is on the policy. - Two names that do not sort as their symbols are numbered: neither is kept, because the symbol numbers contradict a helper name and the object does not say which. Tests: `rpg_sort_names_test.zig` (new): the whole array, `SORTA(D)`, `%SUBARR`, the other uses of the name and the names after it (lsrt-sorta-all, -desc, -char, -subarr-n); a helper suffix of another name (`TOTALS`); a name of 30 characters costs no statement (lsrt-sorta-subarr-sn); the suffixes `1A`, `a`, `_A`, `9`, `A#B`, `A$B`, `A@B`, `#B`, a suffix of 31 characters, `A_00254`, `V00254` and `A_00253_F10` refuse; `sortedBy` of the two directions, of a symbol that is no procedure, of one outside the module and of a changed comparison; `found` with no names, a name of the other direction and a limit below the name; `inOrder` for a name between its neighbours, below, above, equal to the kept name, two out of order, and a drop that exposes a new pair; the suffix equal to the name of another procedure refuses (and names the array when the other procedure has another name); the policy on its own for one array with two names, one name for two arrays, SORTA and SORTA(D) agreeing, a taken name in either case, and the valid names. `rpg_lsrt_test.zig` and `rpg_lsrt2_test.zig` pinned the placeholders of the 14 SORTA probes: they pin the names of the source now (`A`, `C`, `Q`, `INTEGER_LIST`, `ZONED_VALUES`). Before and after, the Debug build of this branch against the Debug build of the ldev3 worktree before this change: the 34 cases of the batteries lsrt-sorta and lsrt-sorta2 change in 14 emits, the 14 that have a SORTA; the 20 `%LOOKUP` cases are the same bytes. In all 34 the counts of statements, emitted and failures and the count of failure and placeholder comment lines are equal. The census is 645 recovered, 0 regressions, 0 newly recovered. The development programs p3 and p4 (a fit measurement, not evidence of a rule) name their two sorted arrays and every use of them as the helper does, and the fields after them take the prefix of the last kept name and `_`; their emitted and failure counts are equal. Whether the recompile of either now matches is the host gate of the coordinator. ## Gate (host round trips, base = ldev3 build, the code of v0.1.520) ``` diff -r -x emit.ndjson -x *.receipt.json /Users/someara/data/sourcerer-loop/runs/emitbytes.mTmu6B/base-emit/608-PA1E46920S.rpgle /Users/someara/data/sourcerer-loop/runs/emitbytes.mTmu6B/head-emit/608-PA1E46920S.rpgle 2,6c2,6 < dcl-s A_00254 char(5) dim(10); < dcl-s A_00255 packed(5:0) inz(3); < dcl-s A_00256 packed(5:0) inz(6); < dcl-s A_00257 packed(5:0); < dcl-s A_00258 packed(5:0) inz(2); --- > dcl-s C char(5) dim(10); > dcl-s C_00255 packed(5:0) inz(3); > dcl-s C_00256 packed(5:0) inz(6); forms projection differs: 564,577c564,577 < {"twin":"savf/SC-ILE/EXPERIMENTS/lsrt-sorta-all/stripped","object":"PFFE7C692S","status":"done","statements":7,"emitted":4,"failures":3,"lines":16,"form_counts":{"array_element_v1":2,"cycle_body_routine_v1":1,"cycle_end_v1":1,"cycle_return_transfer_v1":1,"direct_branch_v1":1,"emit_dcl_s_v1":6,"emit_endfor_v1":1,"emit_for_v1":1,"emit_free_v1":1,"emit_inlr_v1":1,"emit_sorta_v1":1,"emit_summary_v1":2,"fail_statement_v1":3,"placeholder_decimal_positions_v1":1,"static_initialization_v1":1},"text_sha256":"4a9b4eb319a3f381207f9d47d06416104f911633a0bab0ad7945aa4ba30ec93d"} < {"twin":"savf/SC-ILE/EXPERIMENTS/lsrt-sorta-char-desc/stripped","object":"PA1E46920S","status":"done","statements":8,"emitted":5,"failures":3,"lines":16,"form_counts":{"array_element_v1":2,"cycle_body_routine_v1":1,"cycle_end_v1":1,"cycle_return_transfer_v1":1,"direct_branch_v1":1,"emit_assign_field_v1":1,"emit_dcl_s_v1":5,"emit_endfor_v1":1,"emit_for_v1":1,"emit_free_v1":1,"emit_inlr_v1":1,"emit_sorta_v1":1,"emit_summary_v1":1,"fail_statement_v1":3,"layout_blank_v1":1,"static_initialization_v1":1},"text_sha256":"3854cd9faafba1e4c541dfde57cd30a2e7fe39a4f81a4b099cc68435d37a51d7"} == d. captures (capture-emit-diff) p3 base=[18,18,0] head=[18,18,0] CHANGED fail-lines=0 p4 base=[22,22,0] head=[22,22,0] CHANGED fail-lines=0 lsrt-sorta-all base=[7,4,3] head=[7,4,3] CHANGED fail-lines=3 lsrt-sorta-char base=[7,4,3] head=[7,4,3] CHANGED fail-lines=3 lsrt-sorta-desc base=[7,4,3] head=[7,4,3] CHANGED fail-lines=3 lsrt-sorta-subarr-lit base=[7,4,3] head=[7,4,3] CHANGED fail-lines=3 lsrt-sorta-subarr-n base=[7,4,3] head=[7,4,3] CHANGED fail-lines=3 lsrt-sorta-subarr-s base=[7,4,3] head=[7,4,3] CHANGED fail-lines=3 lsrt-sorta-char-desc base=[8,5,3] head=[8,5,3] CHANGED fail-lines=3 lsrt-sorta-dec2 base=[8,5,3] head=[8,5,3] CHANGED fail-lines=3 lsrt-sorta-int base=[8,5,3] head=[8,5,3] CHANGED fail-lines=3 lsrt-sorta-subarr-2lit base=[8,5,3] head=[8,5,3] CHANGED fail-lines=3 lsrt-sorta-subarr-2n base=[8,5,3] head=[8,5,3] CHANGED fail-lines=3 lsrt-sorta-subarr-expr base=[8,5,3] head=[8,5,3] CHANGED fail-lines=3 lsrt-sorta-subarr-sn base=[8,5,3] head=[8,5,3] CHANGED fail-lines=3 lsrt-sorta-zoned base=[8,5,3] head=[8,5,3] CHANGED fail-lines=3 capture-emit-diff: 45 cases, 16 changed, 3 with no failure line in the head emit == e. source agreement (agree) suspect base=76 head=76 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=56 head=56 == f. host round trips (both binaries) cases to round-trip: 3 dev5/p3 base=different head=match dev5/p4 base=different head=match gate: PASS ```
An array that a SORTA sorts keeps the name of its helper _QRNI_SORT_A_<name>
Some checks reported errors
binjovi/ci A newer source or plan superseded this Build
7c49fcb520
The compiler names the helper procedure for the sorted array and the stripped
object keeps the name; the emit called the array A_00256 and the rebuild named
the helper _QRNI_SORT_A_A_00256, which is the only difference of two objects in
the constant area and the initialization.

rpg_sort_names.zig reads which array each helper sorts (rpg_sorta.sortedBy, the
body of the helper) and keeps the suffix of its name as the name of the array
when it is a valid name of at most 30 characters, belongs to one array, is the
only name of that array, collides with no other name of the module, has not the
shape of a generated name, and sorts between the kept names around it
(inOrder). nameSymbols uses it as a kept name, so the placeholders around it
sort between it and the next kept name. Qualified and subfield arrays, and names
with # @ $, keep the placeholder.
sean force-pushed ldev4 from 7c49fcb520
Some checks reported errors
binjovi/ci A newer source or plan superseded this Build
to dfd1fedca4
All checks were successful
binjovi/ci Binjovi completed the frozen plan
2026-11-14 19:28:43 +00:00
Compare
binjovi-bot manually merged commit dfd1fedca4 into trunk 2026-11-14 19:45:07 +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!804
No description provided.