Test / gate (push) Canceled after 0s
The gate first ran on the server that deploys the site: a slow container with no C compiler and no ICU. Ten tests failed there on correct code, and no Mojo program could be built at all. - The workflows ask for a runner labeled heavy, not the deploy server: the gate builds and runs some 300 Mojo programs and fuzzes. docs/ci.md says how to register one. With none registered a run waits. - The pinned environment has a C compiler on Linux (gcc, with its C library pinned to glibc 2.34): mojo build links with the C compiler it finds, and conda-forge's default links against a C library too old for Mojo's runtime. mojo-local reports a program that could not be linked as that, and does not keep the answer. - The pinned Dafny runs without ICU, and dafny-fetch fails when the Dafny it fetched does not start. - A test's time limit is processor time at the machine's pace (tests/helpers/pace.mjs). - The prover's time on the clock is the caller's: provePseudo and Workspace.proofBudgetMs take it, the Prove tab's 3 seconds stay the default, and the command line, library-check and the tests use none, so their answers are the counted budgets' alone. - The library pointer moves to its workflow change (e5ae090).
74 lines
11 KiB
Markdown
74 lines
11 KiB
Markdown
# Changelog
|
|
|
|
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
|
|
No version has been tagged yet. The library, pplus-library, is pinned by commit and has a changelog of its own.
|
|
|
|
## [Unreleased]
|
|
|
|
Mojo 1.2.0, held to the real compiler on the machine as well as on godbolt.org, and the fixes three audits found.
|
|
|
|
### Changed
|
|
|
|
- Everything Mojo is pinned to Mojo 1.2.0 (it was 1.1.0): the pin, the harvested corpus, godbolt's answers for every program, and the words the checker and the editor know. The corpus pipeline reads a release's notes from the nightly changelog when the tag has none, and `pixi run mojo-prune` removes stored answers nothing reads.
|
|
- `pixi run library-check` builds and runs every Mojo reference and the Mojo generated from each routine on the pinned compiler on the machine; every Mojo reference has the compiler's stored answer.
|
|
- The pseudo parser, checker and interpreter (`lang`, `numeric`, `parse`, `check`, `interp`) are strict TypeScript on a typed syntax tree (`ast.ts`), with no change in behavior: 0 differences over 8,451 texts against the JavaScript they replace.
|
|
- A routine's compiled references read their cases at run time; three checks that had agreed only because the compiler worked the answer out while building are now real.
|
|
- New limits, each a located diagnostic or a named stop and all listed in `docs/limits.md`: how deep and how long a Mojo, lingo, matho or pseudo text may be, how large a value a Mojo run may make, how much work the prover and the generated tests may do, and how much memory an x86-64 setup may name.
|
|
- The sources are in US English: `normalizeAnswer` (was `normaliseAnswer`), the lesson and concept id `memoization`, "not modeled" in messages.
|
|
- Mojo is built one stated way everywhere core builds it or asks godbolt to (the Compile button, the corpus, the library's references, `mojo-local`, `mojo-fuzz`, `mojo-run`): the arguments are `build.args` in the library's pin, before a program's own. `--target-cpu x86-64-v3` makes a listing the same whichever of godbolt's machines answers (one answered with AVX-512, which the model machine does not know); `--fp-mode contract=off` rounds every Float64 operation on its own, as both interpreters do, where Mojo's default fuses a multiply with an add. `BUILD_ARGS` carries them and `BUILD_LEVELS` is new. `mojo build` with no arguments targets the machine it runs on and may fuse (`docs/trust.md`).
|
|
- The Mojo syntax definition the pipeline writes states its license as Apache-2.0 (it said MIT), and `THIRD_PARTY.md` says that the engines and the lessons, which came from the course, are under this repository's copyright and license.
|
|
|
|
- `pixi run cli prove` has no time limit unless `--budget-ms` gives one, and `library-check` proves without one: their answers are the prover's counted budgets' alone, the same on every machine. The clock is the caller's (`provePseudo(parsed, { budgetMs })`, `Workspace.proofBudgetMs`); left out, it is the Prove tab's 3 seconds (`PROVE_BUDGET_MS`), as before.
|
|
- The pinned environment has a C compiler on Linux (`gcc` from conda-forge, with the C library it links against pinned to glibc 2.34, which Mojo's runtime needs): `mojo build` links with the C compiler it finds, so until now a build depended on the system's, and on a machine without one (CI's image) no Mojo program could be built. The C references and the C harness are built with it too. `mojo-local` reports a program that could not be linked as that, not as rejected by the compiler, and does not keep the answer.
|
|
|
|
### Added
|
|
|
|
- `pixi run mojo-local` builds every Mojo program core holds or generates on the pinned local compiler and holds the checker, the interpreter and the translator to it; `pixi run mojo-fuzz` does the same with generated programs.
|
|
- `pixi run mojo-fuzz --statements` generates whole programs (loops, branches, collections, records, routines with BYREF), builds each with the pinned compiler and holds its output to the pseudo's line by line; `pixi run prove-fuzz` holds the prover to runs of generated programs. `pixi run ci` runs both on a fixed and a moving seed, and `pixi run nightly` runs them longer.
|
|
- The Mojo interpreter runs what the translator writes: typed list literals, `List[T](slice)`, `ord` and `chr`, std.math's exact functions (`gcd`, `lcm`, `comb`, `hypot`, `fma`, `nextafter`, `ulp`, `copysign`, `isinf` and the others), `atof` of a decimal, and the `match` statement. What it declines on purpose (a fractional power, the transcendental functions, random numbers) says why.
|
|
- CI workflows that run the gate a developer runs (`pixi run ci`: every test, strict corpus status, library-check, mojo-local and a short fuzz), and a scheduled one for the longer fuzz.
|
|
- `docs/limits.md`, `docs/ci.md`, and a test that holds the sources, scripts and tests to US English.
|
|
- Third-party inventories: `THIRD_PARTY.md` here and the library's, written from the pin, the lock and every harvested file, and tests that fail when they fall behind.
|
|
- The Apache License 2.0, a NOTICE, contributing rules, a security policy, a code of conduct, and a citation file.
|
|
|
|
### Fixed
|
|
|
|
- The gate no longer depends on the machine it runs on. It first ran on the server that deploys the site, a slow container image without a C compiler or ICU, where ten tests failed on correct code and no Mojo program could be built. The pinned Dafny starts without ICU (it is run with `DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=1`), and `dafny-fetch` fails when the Dafny it fetched does not start (it printed an empty version and went on). A test's time limit is processor time at the machine's pace (`tests/helpers/pace.mjs`), and the tests that hold what the prover proves give it no time on the clock.
|
|
- The workflows run on a runner with the label `heavy`, not on the deploy server: the gate builds and runs some 300 Mojo programs. `docs/ci.md` says how to register one, and describes the runners as they are (the workflows' comments described a host-mode runner that was never what ran them).
|
|
- The translator writes Mojo the compiler accepts and that prints what the pseudo prints.
|
|
- The Mojo interpreter: a numeric literal beside a Float32 is a Float32; a float to a whole power is computed as the compiler computes it, and to any other power the interpreter declines; a list in brackets takes a List's element type.
|
|
- The prover: 18 rules that proved what a run breaks are closed, each with a regression program in the library.
|
|
- Pseudo: wrong answers (MOD past 2^53, CHOOSE, sums over whole numbers, literals past 2^53, sized types leaving their type, FLOAT32 literals rounded twice, comparisons with USE IEEE), crashes on malformed input, and missing limits (quantifier bodies and the Prove tab's fuzzing now have one), from an audit against exact arithmetic.
|
|
- Pseudo: a FUNCTION called inside an IF, WHILE or UNTIL condition ran twice, because the step's explanation evaluated it again; a second routine of a name was checked with the first one's record, and one named after a built-in could make the checker throw.
|
|
- The translator, from the statement fuzzer: about twenty-five shapes the compiler rejected or that printed something else (two names that become one, a name declared in a block and used after it, a variable some path leaves unset, DELETE on a set, slices, constants' types, CONTINUE in a REPEAT, an argument evaluated once per pass of a loop). Each is pinned in `tests/sync-mojo.test.mjs`.
|
|
- A function sent from a compiled listing to the x86-64 pane brought its read-only data as `bytes 0x.. 0x..`, five characters a byte: with the compiler's half-megabyte table of source locations the setup was 2.5 MB, more than a share link may hold. A long block is quoted text with `\xHH` escapes, which the setup reads back to the same bytes; a `#`, `;` or `//` inside quoted text is text.
|
|
- No text makes a reader or a run end in the engine's own error: 20 nested `ABS` no longer take the prover's memory, 30,000 nested brackets are one diagnostic, and anything a reader still throws becomes `engine-stop` on its pane.
|
|
- `scripts/mojo/listings.mjs` (run by `pixi run play`) wrote every function of a program into its exercise's x86-64 pane, not the one the exercise is about and what it calls as `docs/mojo-corpus.md` says: for `demo` 8,634 lines and a 2.9 MB `listings.ts`, with which the test suite passed a 3 GB memory cap. It writes the entry and its callees again, the stored listing's `build` is the arguments its answer was asked with (the pin's first), and a test fails when `listings.ts` is not what the tool writes or grows past 64 kB.
|
|
- A FLOAT made into a whole number must be one the lab holds exactly.
|
|
- What core said about fused multiply-adds: with its default `--fp-mode contract=fast`, Mojo 1.2.0 fuses a multiply with an add where the operands arrive at run time; core now builds with contraction off, and three library references that needed a tolerance for it agree exactly again.
|
|
- `pixi run mojo-local` compares a program given stdin with godbolt's stored answer too: godbolt does deliver stdin.
|
|
- Pseudo: brackets that each hold a long chain (three levels of 399 values, inside both the 200-level and the 400-value limit) built a tree about 1,200 levels tall, and the checker ended in the engine's own stack error. An expression's tree is now held to 400 levels where it is complete (`MAX_TREE`), one `too-deep` error.
|
|
- `docs/engines.md` is corrected against the code (which modules are TypeScript, which built-ins carry an `argument` obligation, what the reference test runs, what this repository changed in the engines), and the reference says the prover has 3 seconds for each routine, not for the program.
|
|
|
|
## [0.2.0] - 2026-10-06
|
|
|
|
The engines' first home of their own, as `main` holds it. Never tagged.
|
|
|
|
### Added
|
|
|
|
- pplus-core as a project of its own: the languages, translators, Mojo checker and interpreter, prover, fuzzer and x86-64 machine model, with no DOM, used by pplus-web and the course as a pinned dependency. This repository owns the engines, and `pixi run engines-export` gives them to the course.
|
|
- A `Workspace` for one piece of work and what its sources mean; Compile & run goes through a `CompileBackend`; `docs/trust.md` says what each verdict means.
|
|
- Pseudo for numerical work: sized types (INT8 to UINT64, FLOAT32), exact built-ins, `USE IEEE`.
|
|
- `USE` and pplus-library as the submodule `library/`: routines verified once and used by name. The Mojo corpus and its stored answers moved into the library.
|
|
|
|
### Changed
|
|
|
|
- The prover's term language, solver and verification-condition generator are TypeScript, each with tests of its own.
|
|
|
|
### Fixed
|
|
|
|
- The prover is sound for what its gate holds: two rules fixed, missing obligations added, a soundness test over regression programs.
|
|
- A run stops on a FLOAT that is not finite, so proofs about FLOAT hold.
|
|
- "X is in the collection" is known inside a FOR EACH pass, not on the way out.
|
|
- A call's result prints in its own type: a FLOAT result 3.0 is not shown as 3.
|