A remark is the compiler’s third voice beside errors and warnings: a fact it
already holds about your program and never otherwise says. It gates nothing,
breaks nothing, and is spoken only when asked for with -rm | --remarks,
which combines with every road including --run. Each speaker is narrow by
rule: it fires only where its sentence is true and its advice is a mechanical
improvement, it is deterministic, it appears once per site, and it never
repeats a rule the style documents own. Without the flag the compiler prints
not one character more than before. In the editor, the extension shows
remarks in the Problems panel and counts them in the status bar.
$ mica --compile --remarks --source scan.mica --build build
Remarks:
31: m := Find(address r, text, from);
^ analyzer remark 5544 [31,14]: 'Find' re-enters the text at a bare rune position, which under utf-8 walks the bytes from the start on every call, and this call stands inside a loop, so the loop runs quadratically: open a walk with 'MatchStart' and step it with 'NextMatch', which resumes at the byte where the last match endedThe speakers
| Code | Speaks when | The fact, and the alternative it names |
|---|---|---|
5108 | a parameter is never read in its body, and the routine is not a callback | a shape kept deliberately for a uniform family is fine as it stands; a parameter that is simply unused can go. A callback’s parameters are the foreign contract’s, so the compiler never asks about them |
5514 | an indexed string walk stands inside a loop, under utf-8, at the debug tier, and the loop moves the index over the same text: a constant or loop-invariant index, a string the loop assigns afresh, or a value made on the spot draws nothing, because each of those walks linearly | indexing walks from the string’s start at every step under utf-8, so the debug tier runs the walk quadratically; for c in s do reads the same code points in one pass, and the optimizing tiers rewrite indexed walks to a cursor on their own |
5516 | a new stands inside a loop under the fixed-arena memory class, except a dynamic array held by a variable the loop body itself declares, whole or as a field of a record it declares, which the scope drain returns every round | each iteration draws a fresh cell from the fixed budget unless a same-size cell was disposed for the arena’s reuse ledger; reuse one cell across iterations where the value allows it, or size the arena for the loop’s whole demand |
5518 | a string grows by its own + inside a loop | every + copies the whole string built so far; a stringbuffer builds it in place |
5519 | a whole wide plain aggregate is assigned name to name inside a loop, from 4096 bytes up | the assignment copies its whole size once per iteration; work through a pointer to one cell, or hoist the copy out of the loop where the iterations read the same value |
5544 | a regex Find stands inside a loop, under utf-8 | Find re-enters the text at a bare rune position, which under utf-8 walks the bytes from the start on every call, so the loop runs quadratically at every tier; open a walk with MatchStart and step it with NextMatch, which resumes at the byte where the last match ended |
5545 | a Part window is formed from a match’s rune position inside a loop, under utf-8 | Part walks the text’s bytes from the start to the position on every call, so the loop runs quadratically at every tier; GroupPart forms the same window from the walk’s own byte anchor, with Group beside it for the positions |
5546 | a call inside a loop hands a dynamic array, or a record or fixed array carrying one, by its variable or field to a parameter its routine takes by copy; a routine that only reads the parameter already receives it by address and draws nothing, and a routine imported from a library speaks only when the call reads nothing the loop changes, because hoisting is then the one road open | the call deep-copies the value’s heap storage once per iteration; hoist the call out of the loop where its answer does not change, or let the routine take a pointer where its changes may reach the caller |
5547 | the process unit’s EnvironmentList stands inside a loop that does not itself set or remove a variable | the verb builds the whole environment into a fresh list on every call, so every iteration pays for every variable; take the list once before the loop where the loop does not change the environment |
5548 | the process unit’s Spawn stands inside a loop | every call starts a whole process: the kernel’s process creation, the pipes it is wired with, and the program’s own start behind an exec; where each iteration’s work is small, one long-lived worker fed through its input pipe does it without the start |
5593 | a new inside a loop is bound with until to an owner that outlives the loop, the enclosing routine or the program, on the hosted heap | every iteration adds a cell to that owner’s region and none returns until the owner ends, so the loop’s memory grows with its rounds; bind the cell to an owner inside the loop, or dispose it before the iteration ends |
5597 | a routine imported from a C library carries the name of one of the language’s own mathematical words | the compiler realizes its own word at the call site in the operand’s width, a float32 as well as a float64; imp from the language asks for its own, and an alias on the C import says the C function is the one meant |
5613 | a dynamic array made with no until inside a loop is held by no variable, handed straight to a call or used as an operand, on the hosted heap | its backing belongs to the routine the loop stands in, or to the program body, until that ends, so the loop grows by one backing a round; hold the array in a variable the loop body declares, whose scope returns it every round, or in one the loop assigns anew each round, which gives the old backing back |
5617 | a drawn dropout, the residual add of its answer and the layer normalization of the sum stand one right behind the other, on the card or on the processor, or the add calls the dropout itself, and nothing reads the dropout’s answer after the add | the three run as one pass each way, one pass forward and one reverse rule, with the same digits as the three statements run one at a time |
5618 | the three stand as for 5617, but the dropout’s answer may be read after the add: later on, by a routine a later statement calls, in the loop’s next round, behind a leave, or once the routine returns to a caller that holds the variable | the one pass would not store the answer, so the three run one at a time; the remark names the line or the routine that may read it |
5619 | a statement stands between the residual add and the layer normalization of its sum | the three run one at a time; with the normalization right behind the add they run as one pass each way |
5620 | the tape window ends between the residual add and the layer normalization of its sum | the three run one at a time; with the normalization inside the window they run as one pass each way |
5623 | a residual add of two variables read by name, the branch as it stands or widened from a half, and the layer normalization of the sum right behind it, with no dropout before the add, as in a model trained without dropout | the two run as one pass each way, with the same digits as the two statements run one at a time; a statement between them keeps them apart, and no remark says so |
13111 | a store puts a heap cell where the ownership checks stop following it: into a parameter, into a variable whose address is taken or that routines share, through another pointer, or into an aggregate | past that store the checks see no second owner, no second release and no use of the cell after its release; a checked build’s release guard still stops a second release while the program runs |
Inside a loop means inside the part a loop repeats: its body, and a while or repeat loop’s condition. A counted loop’s bounds and a for-in loop’s container are evaluated once, before the first iteration, so a call standing there belongs to whatever encloses the loop.
The speakers 5617 to 5620 and 5623 report an optimization rather than
advise one: where the compiler runs a transformer block’s dropout, residual add
and layer normalization as one pass each way, and, where it does not, why;
5623 where a block trained without dropout runs its residual add and layer
normalization as one pass. The program stays exactly as written either way.
The speaker 13111 comes from the ownership checks, which prove while the
program compiles that every heap cell has one owner and one release. It names
the store where that proof stops, so a cell the checks cannot follow is never
passed over in silence.
Two speakers of the first release, 5515 and 5517, advised away the copy
of a by-value container or wide record that a body only reads. The compiler
now passes such a parameter by address on its own, so the copies they spoke
about no longer exist and the codes are retired; their numbers stay reserved
so no later code shifts.
What the numbers mean
A remark’s code is a code like any other of the part of the compiler that
speaks it, the analyzer’s or, for 13111, the ownership checks’, and it never
collides with an error’s or a warning’s. The number is stable across releases: a
retired speaker keeps its number, and a new speaker takes the next free one,
so a build script that greps for a code keeps working when the compiler
learns to say more.