Repository navigation
Releases
v1.0.0-rc.10.3
A point release for what the first day of rc.10.2 in production found: a check that could take exponential time, a silent miscompile as old as rc.9, and the time and memory the compiler spent writing C. One declaration that compiled is refused now, under Breaking.
Breaking
ERR0414: a function named as the language spells a type is refused where it is declared:byte,f64,int,bool,string8,cstring, and every other primitive and string type. A call written on a type's name is a conversion, so such a function was never called:byte(0.5)answered0whateverbytewas declared to do, with no diagnostic, in rc.9 and every rc.10. Rename the function; for aforeignfunction, keep C's name and give Dado another:@c("byte") c_byte(…). A constant, variable, slot, method, enum member or local of such a name is reached by its name, and is unaffected.ERR0309in a script: a barestring(…),int(…),float(…),print(…)orprintln(…)that a Dado function is also named as — one of the script's package, or one thatimport .supplies — is refused where it is written: the built-in was called and the function never was. Rename the function.
Changed
- The compiler writes C faster and in less memory. On a 144,000-line program the compiler's own time for a native dev build went from 10.0 s to 2.2 s and its peak memory from 2.1 GB to 0.9 GB; the
--releaseweb build of the same program, which needed more than 3.3 GB, takes 3.3 s and 1.1 GB. A type's canonical shape is worked out once, not at every use, and a web build works out which functions cross inline once for all its script classes, not once a class. The C written is the same. - The same source gives the same C on every run. A trait value over the instances of a generic type took its arms in a hash table's order, so instance numbers and the order of the C could change from one run to the next, and an object cache missed with them. The arms are in the order the instances are made, and
DADO_HASH_SEEDis no longer needed for reproducible output. dado buildanddado checksay how the compiler ended when it did not finish:the compiler was killed (signal 9): the system may have run out of memory,the compiler aborted (signal 6), or its exit status, with the compiler's last line, where they said only "transpiling failed".
Fixed
- A program whose packages share a name took exponential time and memory to check or build: 2.5 GB for sixteen pairs of namesakes, and a tree with twenty shared names was killed past 5.5 GB. A package's key was worked out again at each use, and a namesake's asked for every earlier package's; it is worked out once. The keys are the ones rc.10.2 wrote. rc.9 was not affected.
- A
foreignconstant or variable named as a type (C's name, which@ccannot change) is read as its value again, as in rc.9; rc.10 refused it or stopped in the compiler.
v1.0.0-rc.10.2
A point release that repairs fifteen more regressions against rc.9, all of which came with rc.10: programs that rc.9 built and ran, and rc.10 or rc.10.1 refused, miscompiled or could not build for the web. Every workaround written for them still builds, and none is needed now.
Fixed
- A
--releaseweb build of a script class that uses two or more other script classes failed: "names a module the build did not write, which the bundle takes from no module". The bundle read the line holding a module's class imports as one import. It reads every import on the line, and one it does not know is refused by name. (rc.10 built such a program only because it left the classes of aproject:package empty.) - A
--releaseweb page asked for every script the bundle had folded intoregistry.js: its manifest listed ajs-modulerow for each module, so the page preloaded files the build never wrote, a 404 and a console error for each. A release build's manifest lists the bundle and the files it keeps, as rc.9's did. - A web build of more than about 245 source files failed to link: "a command of N words is more than the 255 this driver can start". A web build is a unit a source file, and the link named every object on its line; it goes through a response file, as the native link does, written as the linker reads it.
dado build,dado runanddado testwith--target=web, a dev build and--release. - DadoScript: a store through an
anythat was not reached from a name was dropped, with no diagnostic.m[k].f = v,xs[i].f = v,g().f = vandhandle.field.f = v(ananyfield of another class's instance), and the same a member deeper (m[k].a.f = v), compiled to a read whose answer was thrown away. They store.g().f = vis accepted (rc.9:ERR0606): ananyis a reference to what it holds. - DadoScript: a method call through the same receivers (
m[k].f(),xs[i].f(),g().f(),handle.field.f()) wasERR0001("outside the slice the port builds so far"). Ananyis called through whatever expression answers it. - DadoScript: a store through a container or an
anyinside a parenthesised list of places ((xs[0], n) = (5, 1)) was dropped with no diagnostic. It isERR0606, naming the place: assign it on a line of its own. A script's store whose target is a value and not a place is never compiled. - A record that holds a run of itself, held by value, wrote C that did not compile. With
type T: … ref []T children: a[2]T, a pack..T, aTor[N]Tslot of another record or tuple, a{K: T}. The C had a second struct forTwherever it was held. A slot of function type that names its own record (i32(T) visit,T() make) compiles and runs: a function value is a pointer to code, so the record does not hold itself (rc.9:ERR0507; rc.10 and rc.10.1 accepted it and never finished compiling it). Should one type ever be given two C names again, that is an internal error and no C is written. - A
foreignblock'sflags "-Wno-X"was ignored, so a header that needs the clause did not compile under gcc:vendor:sokol/sokol_appon Linux stopped at "ISO C forbids conversion of object pointer to function pointer type". The header's#includeis written between#pragma GCC diagnostic push,ignored "-WX"andpopagain, as in rc.9. - A single-header library reached only through a package that names its header was read without its backend:
sokol_gfx.hstopped at "Please select a backend with SOKOL_GLCORE, …", or was not found at all, in a program that reachesapp:ui/gridand calls nothingvendor:sokol/sokol_gfxdeclares (dado test collections/app/ui, a headless program overapp:ui).app:ui/gridnamessokol_gfx.hto put it above its shader header; thedefinebeside the binding itself (the backend, with itslink) was dropped as unreached, and so was the-Iof the package that holds the header. A block that declares nothing and carries adefine, in the package that binds its header, is kept wherever that header is read. - A window with no low bound over an empty run stopped a program sanitized by clang:
xs[:]orxs[..<n]wherexsholds nothing yet wroteptr + 0on a null pointer, and clang's UBSan reported "applying zero offset to null pointer" (dado test --cc clang; five of the standard library's own packages failed their tests so). The window is written with the run's pointer as it stands, as in rc.9. - Valid code refused:
- a value copied out through a pointer or a
for &rloop into storage that outlives the frame, where the value holds no view of the frame (KNOWN[k] = r^walkingfile.rows):ERR0826. A pointer into a window a record holds (&file.rows[i]) points at what the window views, not at the record; - a generic call with two parameters of different
distincttypes over one base, neither of them a generic parameter (make($L lane, VxId z, OrId outrec)):ERR0504, "bindsthe tag"; - an array or matrix combined with a conditional between numbers (
[3]f64 v = a * (-1.0 if flip else 1.0)):ERR0504, once an arm. The conditional is one number and the operator applies it to every element, as it doesa * -1.0. Literal arms take the array's element type as a bare literal does, so integer arms beside a[3]f64and float arms beside a[3]f32are accepted too (rc.9:ERR0504).
- a value copied out through a pointer or a
- Valid code the C compiler refused: a scope with a
deferthat ends by leaving, where every arm of anif/elseor aswitchends a function that returns a value so (if k == 0:/defer note(n)/return n > 0/else:/return true). gcc stopped at "control reaches end of non-void function" in a debug or sanitized build (dado build --debug,dado testwherever gcc has AddressSanitizer); clang,zig cc, an optimised gcc build and the web target took it. The scope's deferred statements were written a second time after thereturn,fail,breakorcontinuethat had already run them. Nothing ran the copy, and it is not written: a deferred statement still runs once on every path, as in rc.9. - Linux with gcc: a script host did not build. Two causes, both since rc.10, the first on x86-64 and the second on aarch64 as well:
- a script module of more than 4,000 bytes holding a character outside ASCII wrote its bytes past 127 as
226into aconst char[], which gcc refuses under-Werrorwherecharis signed ("overflow in conversion from 'int' to 'char'"); clang andzig cctook it, and so did gcc on aarch64. Such a byte is written as a character constant ('\342'), the same byte under either sign ofchar; - the link named
-lmbeforelibquickjs.aand dropped the engine's own-lmafter it as a repeat, so under GNU ld with--as-needed(gcc's default on Ubuntu) QuickJS'sexp,cos,sqrtwere undefined, indado build,dado runanddado test --no-sanitize. A repeated-lword is kept at its last place.
- a script module of more than 4,000 bytes holding a character outside ASCII wrote its bytes past 127 as
- The one-file C (
--emit=c) of two builds did not compile under clang: a#NONEprogram whose runtime namesfwriteonly where a trace is kept (core:log) had an unused stand-in (-Wunused-function), and a web program that runs scripts held the web engine's unit, which defines the typesquickjs.hrestates, a second time. The stand-ins are marked unused, and the engine stays a unit of its own, as in rc.9. Builds throughdadowere not affected.
v1.0.0-rc.10.1
A point release that repairs rc.10's regressions: programs that rc.9 built and ran, and rc.10 refused, miscompiled or lost. Every workaround written for them still builds, and none is needed now.
Fixed
- A conversion to a written-out array, slice or tuple type compiled to nothing.
([3]f64)(1.0, 2.0, 3.0),([2][2]f64)(…)and([2]V3)(…)were checked with no diagnostic and the whole statement dropped: an initializer left the variable unset, an#appendadded nothing, an assignment never happened, a call taking the conversion vanished, andreturn ([3]f64)(…)became a barereturn;. They construct the value again, as rc.9 did, and((f64 x, f64 y))(1.0, 2.0)is accepted again (rc.10:ERR0601).([]T)(x)converts one value, as before; the bare[3]f64(…)is stillERR0201. A statement the checker can give no value without reporting why is now an internal error rather than silence. f()^.method()on a^selfmethod wasERR0606("a value with no place"), and so wash().p^.bump(); a deref names existing storage, and the method changes it.selfin a^selfmethod is^Wagain, as in rc.9: it is dereferenced where a slot is read through it (self.n), not when it is named.rawptr(self)works again (rc.10:ERR0504, spelling the typeW). As in rc.9,W c = self,take(self)for aWparameter andself = oareERR0504(writeself^),self == nilis accepted, andfmt.println(self)prints the address.- Indexing a
[1]cstring(and a[1]of a#c.*scalar, a function reference or a union) wasERR0001; it indexes as a run of one again. An index other than0on a value that is not a run (k[1]on ani32or acstring) isERR0519again (rc.10 accepted it). - Indexing through a pointer was not checked.
p[i]on any^Tcompiled to C pointer arithmetic, sop[2]on a^ref []i32read past the value it points at.p[i]indexes what the pointer points at again, checked as if written on it: a value that is not a run has only slot0(ERR0519for another), an index into a run is bounds-checked, and a window over a pointer to a run is a window of the run.&p[i]through a^constis a^const(rc.10 gave a writable pointer).p[i] = con a^string8isERR0606, as on astring8. cstring==and!=wereERR0607; they compare the two pointers, as in rc.9: whether they name the same text in memory, not whether the texts are equal. Compare the contents throughstring8for that.#sendof a constant composite value into a channel field (#send(q, 0, nil)into aref []char8field) wrote C that did not compile.- Web builds dropped a package's C sidecar and its
exports. The manifest of a--target=webbuild lacked itssource,include,headerandc-exportrows, so a package's.cfiles were neither compiled nor linked, andexportfunctions were missing from the module. They are back, and each export is listed in the module's exports. - An
exportfunction that no Dado code calls was lost natively too: a dev build left it out of the executable's dynamic symbols, a--releasebuild removed it, and anexportin a collection package was never compiled. Everyexportis compiled and visible, as in rc.9. dado testfailed to link on its second run ("multiple definition") in any package with a.csidecar, includingvendor:enet: a cached run linked one object twice and dropped the sidecar's.- Embedded JavaScript modules imported by relative path did not load. With the main package below the project root (
main/), modules were laid out under their host path (dados/js/home/…) and some specifiers came out asjs:/…or….js.js; and animportorexport … fromwritten over several lines kept its unlinked specifier. Modules are laid out underdados/js/__up/…again and every specifier is linked where it is written. - Valid code refused:
- a generic bound once through a type's name and once through the shape it names (
PointDand[2]f64):ERR0504; - a failable function with one named result returning a value of that type (
!([3]f64 centroid) mid(…)):ERR0701. A one-slot named result is its element, sov.centroidis the whole array (rc.9 read its first element); &&and||with aconst booloperand:ERR0504;- a constant expression as a
caselabel (case 0 - 1:):ERR0901; - a slot name of a named-tuple result through an
autobinding (auto r = f(),r.ok):ERR0410; - indexing through a pointer to a tuple (
p[0].owner[i]withpa^(^const Coll, []const i32)):ERR0504/ERR0410; - a conditional with a literal arm as a generic argument (
math.clamp(y, 0.0 if peak else LO, HI)withLOanf32):ERR0504.
- a generic bound once through a type's name and once through the shape it names (
dado checkmissed errors in imported collection packages. Code in a package imported asproject:x,vendor:xor another collection was diagnosed only where the program reached it, sodado check maincould pass while checking the packages one by one found errors.dado checkand the editor report errors in every body and package-level declaration of them again; a script class in such a package that a program runs is checked in every build, as rc.9 did (rc.10 accepted arithmetic onanythere, and missedLNT0412).
Changed
These were in rc.10 and are kept; they were missing from its notes.
dado buildtype-checks only the library code the program reaches;dado check(and the editor) check all of it. rc.9's builds checked all of it. Rundado checkto see errors in library code nothing calls yet.- A
ref []Tslot read through a^constis a[]const T:f(s^.positions[0..<2])with^const Soup sisERR0504for a[]f32parameter (rc.9 accepted it). Take^Soup, or make the parameter[]const f32. [x]is one value where a run is wanted:set([subject])for a[]const i32parameter isERR0504, since a[1]Tis aT(rc.9 accepted it). Pass a run ([2]i32 ids = …; set(ids[:])) or make the parameter a single value.dado inspect --format=jsonnames tuple slots in signatures:([3]f64 a, f64 gap)(rc.9:([3]f64, f64)).
v1.0.0-rc.10
Breaking
ERR0540: a string literal made acstringholds no NUL.cstring s = "a\0b"compiled and handed C"a", the rest lost without a word, since C reads acstringto its first NUL; it is refused now wherever a literal becomes acstring— a binding, a constant, an argument, a return, a default,cstring("…")— and the message names the byte and what C would read. The same literal still fits astring8,string16orstring32, whose length counts the NUL as one more unit. Write the literal without the\0, or keep bytes that hold one in astring8or a[]char8and pass its pointer and length.
Added
- Copying into a run that already exists. A slice assignment copies an exact window:
dst[i..<j] = src, anddst[:] = srcfor the whole run; the lengths must be equal, which isERR0617when both are known before the program runs and otherwise a trap naming both.n := #copy_into(dst, src)copies as many elements as both hold, from the start of each, and answers the count (i64), as Go'scopydoes. Either side is a fixed array, a window or aref []T; the destination is a place (ERR0606for a[]const T), the element types are the same (ERR0618: a copy converts nothing), strings, maps, pointers and single values are refused (ERR0619), and the two may overlap, asmemmove's may (xs[1..<n] = xs[0..<n - 1]shifts a run up by one). Native and the web; DadoScript has neither form. See "Copying into a run that already exists" indocs/language.md. T(), the zero initializer: for a declared typeT, the valueT twith no initializer gets — each slot at its default, zero where it has none — written as an expression (return T(),f(T())). WhereT tis refused,T()is refused the same way.- Math intrinsics:
#sin #cos #tan #asin #acos #atan #atan2 #sinh #cosh #tanh #asinh #acosh #atanh #pow #sqrt #cbrt #exp #exp2 #log #log2 #log10 #fma #floor #ceil #round #trunc #abs #min #max, generic overf32andf64(#abs,#minand#maxover integers too), lowered to what the target has (libm or a builtin in C,Mathon the web). DadoScript has them as globals (sin(),pow()), which a declaration of the same name shadows. A call whose arguments are constants folds, with the target's own implementation where the compiler has it and the host's libm otherwise. Results may differ in the last bits between targets;core:mathis unchanged, for results that must not. - Signals in DadoScript:
signal died(int hp)declares one in a script class, beside its fields and methods (a field, method or signal of one name isERR0402).died.connect(f),died.disconnect(f)anddied.emit(hp)in a script; from Dado through a handlegof the class,g.died.connect(f)with a package-level function, org.died.connect(T.m, p)with a method bound to a pointer. An emit is synchronous: it calls every connection now, on the emitter's thread, in connect order; connecting one already there does nothing, and a receiver's parameters cross as a script's call of a Dado function's do (ERR1206for one that cannot).
Changed
- The compiler is self-hosted.
dadocanddado-lspare written in Dado (collections/language,tools/dadoc,tools/lsp) and the Rust compiler is retired. A checkout builds with a C compiler alone:./dado_build.shcompilesbootstrap/dadoc.c(the compiler's own C), then the compiler builds itself; no Rust or cargo is needed. Release archives shipdadobesidedadocanddado-lsp, andinstall.sh(install.bat) runsdado install(old:dadoc bootstrap, which the newdadocdoes not have); an install keepscollections/language, from whichdado updaterebuildsdado.dadoc --versionnames the version on its first line, as before, andself-hosted (tools/dadoc)on its second (old: Rust's commit, build date, rustc and zig lines);dado-lsp --versionnames the release (dado-lsp 1.0.0-rc.10). - Builds are faster from cold, and the C a build compiles is smaller. Measured on a 4-core Linux machine with gcc, each against rc.9's compiler:
dado build tools/dadoc11.8 s (57.5 s), and 19.3 s with--release(74.3 s);dado build tools/dado3.5 s (4.1 s), 5.4 s with--release(7.3 s); a small program,corpus/asteroids, 0.19 s (0.39 s). A many-file build's C is 36–49% smaller, since each file's header holds only what its code uses. Builds with nothing changed take what they did (the caches'). Checking runs at 266,000–716,000 lines a second through the type checker (rc.9's: 31,000–168,000), and the ownership analysis behindERR0803andWRN0803checks the compiler's own 75,000 lines in 1.1 s, where rc.9's took 37 s over the 59,000 it had then. Built programs run within 5% of rc.9's, native, on the web and in DadoScript, dev and release. - The many-file form is cut by source file, where it was cut by package: a dev or test build compiles a C file per source file, a release build gathers files into C files of up to 512 KiB (
DADO_UNIT_BYTES;0, a file each). - Diagnostics are listed in order of phase, then file, then position (rc.9: the order they were found), so when there are more errors than are printed in full (12), the ones shown can be different ones.
WRN0803warns where a hazard is real: sites rc.9 warned at that cannot dangle (a view of text kept in package storage while a run of another type grows, a field path the moved run is not on, …) are no longer warned about.dado checkand the editor analyse every library body, reached or not; a build analyses the bodies the program reaches (rc.9: both).- The C a build writes only to hand to the C compiler is deleted after it runs, whether it succeeded or not (rc.9 left it in the build directory):
dado build --keep-ckeeps it, anddadoc --emit=c(on standard output when no-ois given) writes the one-file C for reading. ERR1029checks aforeignname against the C names the compiler now writes, not rc.9'sdado_<pkg>_<name>anddado_tupN_…spellings.dadoc --emit=manifest: the C spellings in it (symbols' parameter names, shapes' C names, member names and offsets,header.declarations) are the new compiler's, and thehheader declares a readabletypedeffor each exported shape — its declared name, and for a shape written out its old mangled name (dado_tup2_i32_i32) — so C that calls a library never names a hashed type.- In a file that does not parse, the editor shows the syntax errors and fewer of the checker's errors that follow from them.
Removed
core:slices:copy_into(from, into). Its order was the reverse of the#copy_into(dst, src)builtin's; writen := #copy_into(into, from)(the count, the shorter length), orinto[:] = fromwhen the lengths are equal (an exact window; see "Copying into a run that already exists" indocs/language.md).dadoc --emit=ast,types,views,h,narrowings,raises,strategies,crossingsandplacement: no tool, editor or check of the toolchain read them (his thehextension of--emit=manifest, throughtools/manifest/h.mjs).dadoc serve,launch,bootstrap,--emit=buildand--transpile-cache=, and its web-page writer:dadodoes each (dado install,dado build,--build-manifest=, the driver's own caches).dado-lsp: completion, code actions and rename, which the Rust server had; diagnostics, hover and go to definition remain. They return in a later release.
v1.0.0-rc.9
(since v1.0.0-rc.8.1)
- release 1.0.0-rc.9
- dado: no link-time optimisation under zig for a macOS program
- tests: re-bless the core:script cases after its comment edit (hashes only)
- CHANGELOG: date 1.0.0-rc.9
- WORKORDER-rc9: I198 landed; CHANGELOG: the three symbolic-link fixes
- dado: compare a package's paths with dadoc's and the root's with links followed
- WORKORDER-rc9: MTU D's user docs landed, the rest carried; CHANGELOG: the ERR1007/1011/1031 rule text
- CHANGELOG: the unit-keying bullet's collections/app/ui times are the measured wall times
- docs: how a program is built now (multi-TU piece D)
- WORKORDER-rc9 batch 3 and rc.10 carry; CHANGELOG rc.9 to release shape
- dado test: a program's key leaves out the test files it does not hold through a link
- check.sh: the test_programs and threads e2e modules run in the core group
- dado_emit_c: find a function's marks once, on its worker
- dado_check: DADO_TRACE=par, the body pass's parallelism probes (TH0)
- dado_emit_c: write the program's functions in parallel (TH1)
- dadoc --threads: parse a program's files in parallel (TH2)
- dado test: one program per group of a package's test files
- dado build, dado test: no link when no object changed
- dado test: the emit slot is a test's one copy of its C
- dado test: hash each source and the dadoc binary once, not once a test
- dado build, dado test: key a C unit without cc -E
- WORKORDER-rc9: batch 2 (build time) recorded; threading phases; T106-T109, Q30
- dado: an install's checkout builds into the install's build/, beside it
- dado, dadoc launch: a dev compile under zig says -fno-sanitize=undefined
- dado build: no link-time optimisation for a #NONE object
- check.sh: sweep dado's units cache, not the retired obj cache
- provenance: keep each type's holds-a-handle answer for the pass
- dado test: a test's emit key hashes its sources with xxHash64
- dado_types: the arena's chain walks allocate nothing for a short chain
- tests: re-bless the declarations of the files dado test's split changed
- dado test: on the split, cached, several at a time (multi-TU C)
- dado_check: a file's name tables catch up on what changed instead of rebuilding
- dadoc: a checked compilation no longer relexes every file
- dado_check: when::resolve copies only the files that hold a when
- dado_check: target::intrinsic looks a name up without allocating
- dadoc, dado: a transpile cache; the launched driver gets a path of its own
- dado_check: a try's refused call is that try's, not the next one's
- scripts: check_cache_equiv.py, the body cache's equivalence harness
- dadoc: the body-pass timer splits main from imports
- dadoc: per-pass and per-package check timers under DADO_TRACE=time
- dadoc: the prune fold, emit from the one check (DI-0340's prune half)
- Multi-TU A: release builds on the split with LTO; --one-file removed
- dadoc: no C emission for a question about the diagnostics
- dado check: one dadoc run (dadoc --emit=check)
- dadoc launch: build the driver by its units at -O0, cached
- WORKORDER-rc9: batch 1 recorded; multi-TU and build-time rows; T101-T105
- tests: re-bless pipeline's declarations after its strncmp
- gate: step 9c's red message prints its -O0 line
- tests: re-bless inline-c for pipeline's strncmp
- bindgen: format a binding under the harness's pinned .dadofmt
- tests: re-bless emitted-size after the #append break's growth helpers
- gate: the e2e growth module runs in the core group
- corpus: pipeline compares zlib's major version, as inflateInit_ does
- tests: the DadoScript host cases regenerated (core:script, core:fmt rewritten)
- tests: snapshot reds on the integrated branch, regenerated or restored
- tests: three e2e sources the growth rewrite missed (Rust string literals)
- dadoc: the editor actions' tests expect a function body under its signature
- tests: tools/dado declarations regenerated after the i88-cap merge
- tests: the five provenance cases re-blessed on the integrated branch
- tests: the growth cases the rewriter left, by hand (A5; I155)
- rc.9 I88 (T45): the terminal shows 12 errors; --log FILE keeps them all
- toys-lab: the seed-clipper2 growth sites, by hand (A5; I155)
- collections: the growth sites the rewriter left, by hand (A5; I155)
- ide: archived, not ported (I62)
- dadoc: hover of a compiler name is the lexicon's row, tested (I113)
- docs: the growth break taught everywhere (A6; I155)
- checker: a record copied after a slot moved; function values by type (A2; I155)
- checker: the review of growth provenance (A2; I155)
- fmt: a function body stays under its signature by default (fold_function_body)
- tests: declarations and LSP replay pages regenerated (A4; I155)
- checker: provenance for growths that answer the handle (A2; I155)
- docs: core:flags and core:strings regenerated (A4; I155)
- tests: growth calls rewritten (A4; I155)
- core:script: reload's read loop stores the grown handle (A4; I155)
- corpus: growth calls rewritten (A4; I155)
- toys-lab: growth calls rewritten by dado fix append (A4; I155)
- dev, example: growth calls rewritten by dado fix append (A4; I155)
- collections: the growth sites tools/dado needs, by hand (A4; I155)
- collections: growth calls rewritten by dado fix append (A4; I155)
- tools: growth calls rewritten by dado fix append (A4; I155)
- dadoc --fix=append and
dado fix append: the growth rewrite (A4; I155) - checker: a typed
_drops a growth (ERR0829);..stext into a char8 run - checker: ERR0504's growth help within 160 characters; neg_growth_answer
- emit_c: growth answers the handle, traps, and grows a nil run (A3; I155, I126, I149)
- CHANGELOG: completion at block heads, in parameter lists and after a stray suite
- completion: nothing after a block head's
:, in comments or strings; a stray suite stays in its function - CHANGELOG: vendor:raylib binds the whole header
- vendor:raylib: bind the whole of raylib.h
- checker: the growth verbs answer the handle (A1; I155, I126)
- rc.9 opened: WORKORDER-rc8.md -> WORKORDER-rc9.md (T98, T99, T100)
- version: the rc being built is 1.0.0-rc.9 (I104)
v1.0.0-rc.8.1
(since v1.0.0-rc.8)
- release 1.0.0-rc.8.1
- CHANGELOG: date 1.0.0-rc.8.1
- rc.8.1: warnings are counted in build output;
dado warningslists them - rc.8.1: the Windows installer keeps its window, retries, and keeps PATH variables
v1.0.0-rc.8
(since v1.0.0-rc.7.1)
- release 1.0.0-rc.8
- CHANGELOG: date 1.0.0-rc.8
- Work order: the 2026-10-24/25 batch gated green at a5548c0c; T97; I147-I154
- Regenerate .c snapshots on the integrated fulltrace + cborfix tree
- emit_c: zero a failable call's destination with the call stack too; step 11 is plain
- emit_c: zero a failable call's destination in a sanitized build
- dadoc --full-trace: the shadow stack is its own switch, off by default
- tests: re-bless emitted-size after the alignment, __multi3 and #location merges
- Regenerate snapshots and docs after merging 'align'
- Allocate a type aligned beyond 16 aligned for it
- e2e s11_5: a listed native stand-in is not the program's C
- Declaration snapshots of tools/dado regenerated on the integrated tree (tiers, compiler discovery, linkfix's toolchain.dado, lsp132's doc lines)
- #location() as a default is the caller's place; folds in const/var initializers
- dado api: a method with its type; a script class's foreign helpers off the surface
- One reader of where a doc comment is: dado-lsp's page and dado doc params read it
- dado-lsp: DadoScript members through an instance, and class names
- dado: build tiers and per-feature switches; one C compiler discovery for builds and doctor
- A #NONE triple for another machine compiles for that machine
- Every web build defines compiler-rt's __multi3, sanitized or not
- WORKORDER-rc8: T93 confirmed (Q27); T94-T96; F15 stays in rc.9; rc.9 design notes; I140-I146; where it stands, 2026-10-24 afternoon
- #location(): the place it is written, as a Location constant
- K29 review: the web's UBSan report is compiler-rt's for a negation and a 128-bit operand
- K29 review: red test, a #new of a type holding a channel traps on the sanitized web
- K29 1b U3: the driver sanitizes C on the web and #NONE with UBSan alone
- K29 1b U4: the web loader names a trap in C's silent UB checks
- K29 1b U2: dadoc --ubsan-handlers, C's UBSan handlers on the web and #NONE
- work order: K28 step 3 landed (K28 complete for rc.8), T92 confirmed by Sam, T93, Q26 answered, Q27, I139
- K28 step 3: compile-time interning (o7) on the web, on by default
- work order: the reset, K28 step 2 landed, step 3 in progress, T92, I134-I138
- tests: recursion_through_runs runs every line of its C
- dadoc: a placement figure reads its op's row by rule, not by key order
- costs, seambench: cost keys in the planner's vocabulary (plan::cost_key)
- costs, seambench: cost keys
seam.*for crossings; run.py reads --emit=crossings - dado_check: one crossing plan, computed once, read by both emitters and the reports
- tests: re-bless script .types and diagnostic lengths after K10/K9's function-type display
- docs: language.md documents K10 and K9's conversions, nil and windows
- work order and handoff: K10 and K9 landed (tier 4 complete), T91
- dado_check: a refused call's bindings add no second refusal
- dado_check, dado_emit_c: a name written [1]T is windowed as a run of one
- dado_check, dado_emit_c: nil is the empty slice, and a nil default folds
- dado_types, dado_check: a function answering a run prints its return bracketed
- dado_check, dado_types: a slice or a ref bounds a recursive type
- handoff: batch 5's gate green but for audit G, fixed
- emit_c: the trampoline comment states the rule instead of citing a document (audit G)
- handoff: batch 4's reds fixed; TMPDIR for gates beside agents
- tests: union_widening and bitwise_compound_assign run every line of their C
- dado_check, dado_emit_c: u64(p) and i64(p) read an address as a number
- dado_parse: a type body spells a function type answering a tuple
- dado_check, dado_emit_c: a one-element array literal takes the shape whole
- dado_check: a vector literal beside a matrix takes the matrix's element
- emit_c: core:threads' web and Windows trampolines push no shadow-stack frame
- tests: greeting's quit is matched by its two ends, as the sanitized snapshot writes it
- dado_check: literal arithmetic beside a shape takes the shape's leaf
- handoff: K28's harness merged
- handoff: rc.8's state for the next primary agent
- dev/seambench: the seam's fixed benchmark suite and its first measurement
- work order: rc.8's progress to the handoff, T90, I127-I133
- dado_emit_c: a report's enum or bool argument is evaluated once
- tests: tools/dado declaration snapshots after merging K12 with K13/K14
- dadoc: reword only a genuine key, not a file declaring another package
- tests: refused_packages_said_once, called by name (audit C)
- diagnostics: a package refusing the build with its static_assert says only that
- check: the C math table sits above nearest.rs's tests module
- names: the leftover sig_ and emit names for channels say chan_ and send
- dadoc: a keyed package is named by its declared name in diagnostics
- build: a C failure with no foreign block of the program's own says so
- check: a class instance has identity and no other operator
- docs: #delete's DadoScript row says m.delete(k)
- check: a C math name through core:math names the package's spelling
- check: #copy of a string8 names strings.clone, not =
- check: a conditional over a lend names the binding, not a conversion
- lex: a line ending in && or || is one diagnostic saying to bracket it
- tests: declarations snapshots after the driver and app test changes
- parse: using (proc, nil): opens a suite
- parse: ERR0209 in every declaration name position
- parse: import under a file-level when says imports are not conditional
- parse: a class field takes a trailing comma
- lang: the bitwise compound assignments &= |=
= &= <<= >>= - dado build: a Windows target's program is named .exe
- tests: emitted-size baseline gains the shadow stack's note helper (one line per program)
- dado: DADO_TARGET alone sets zig's target for another hosted system
- emit_c: a call's place in its caller's frame is stored through a call
- dado: a stale sanitizer probe is asked again; where and doctor name the sanitizing compiler
- app:config and app:net tests pass on the web
- dado: every verb in a project builds into the project's build/
- dado test and run report a program that could not start
- dado check --tests checks the @test files; a named test file is checked
- check: a local type binding keeps its own view across a template call
- dado test: one test file of a library runs against its package
- fmt: a case arm ending in an open try keeps its suite below before an else arm
- dado test: name each configuration's C as its binary is
- dado --version prints the driver's and dadoc's versions
- gate: the trace e2e module joins the core group
- tests: the LSP's core:log page snapshot after StreamSink dropped min
- checker: K3b review fixes (distinct handles are one block; frame escapes through ^^ and callee stores; WRN0826)
- dadoc query: one surface reader for inspect, api and doc; cache keyed on the compiler
- hover: a declaration's signature and doc comment, across packages
- tests: K3b review red tests (escape check's rest, 5ed6fe5e)
- checker: a one-slot pointer implementer reads its slot through ^self; a private type reaches another package's trait binder
- dado-lsp: hover a
#intrinsic or@attribute with its signature and description - dado-lsp: complete
#intrinsics and@attributes - Dado sanitizer phase 2: the shadow stack, #trace() and Location
- checker: the escape check's rest (keep(p) through a pointer local, holes closed as warnings)
- tests: inline-c baseline counts one more unmarked foreign function
- gate: the stale and review5 e2e modules join the core group
- collections: drop the union hand wrapping and the always-failing helpers
- checker: a member converts into its declared union; ERR0724 refuses only proven non-members
- hygiene: audit G citations reworded; byte_views runs the root allocator's arms
- check: a type named like one of the language's own types (ERR0414 widened, WRN0420)
- Dado sanitizer: a free is witnessed only when it is real; review 5 fixes
- Review 5 of the escape check's split and the Dado sanitizer: red tests
- work order: T89, I119-I126, tier 2 landed with K3c and K29 phase 1
- docs: the codes index lists ERR0803 again (stale since 254a78f0)
- tests: tools/dado/query.dado's declaration snapshot, stale since 254a78f0
- CP-6 close: the CP-6 status note, for Sam's ruling
- CP-6 close: fmt's Pad measures display columns
- Dado sanitizer: watch only reads that reach memory; docs regenerated
- Dado sanitizer: a growth in a conditional operand is witnessed where it runs (test)
- dado: one sanitizer switch; --sanitize=dado for Dado's sanitizer alone
- Dado sanitizer, phase 1: witness checks at WRN0803 reads, and dadoc --sanitize
- escape check: ERR0803 needs a local proof of a memory access after a real free
- CP-6 close: DI-0151's docs half (a ref []T is made before it grows)
- CP-6 close: step 10's follow-ups (net, http, http/server)
- CP-6 close: the leftovers today's steps found
- K3c fourth review: red tests for false ERR0803s after the third fix
- escape check: a proven free needs an allocator that frees, a path that runs, and the language's order
- K3c third review: red tests for false ERR0803s in the must/may split
- CP-6 step 9: core:json and core:cbor to their 1.0 shape
- tests: tools/dado declaration snapshots for the sanitizer fallback and dado check's warnings
- escape check: a read after a free on every path is ERR0803 again; a possible one stays WRN0803
- core:math, linalg, geom: promise math.root and what it unblocks
- ERR1227 accepts <math.h>'s sqrt and sqrtf, by a named list
- B57: core:geom/bvh's raycast takes one trait, RayTest
- core:geom: drop the #NONE arms around #assert
- #assert on #NONE lowers to a trap instead of ERR1004
- #assert_raises on a method: the declaration form in a type body
- K9a: bytes and text are views of each other (DI-0050)
- escape check: fail safe where the slot precision's preconditions are unknown (K3c second review)
- work order: T85-T88 (the checker an aid, the Dado sanitizer mode, ...
v1.0.0-rc.7.1
(since v1.0.0-rc.7)
- release 1.0.0-rc.7.1
- rc.7.1: ERR0803 is now WRN0803, a warning (T82); dado-dev package point
v1.0.0-rc.7
(since v1.0.0-rc.6)
- release 1.0.0-rc.7
- tests: SSH addresses use a dotless host, so the release leak check does not read them as e-mail
- rc.7: packages loop, correctness cut, gate green
- RPC specification kickoff brief: primer, boundary thesis, the proposal, and the request to begin the official spec
v1.0.0-rc.6
(since v1.0.0-rc.5)
- release 1.0.0-rc.6
- rc.6: Sam's planning notes: api and rpc for rc.7 (F15, dado-1.0.0-rpc.md), sequence reduction and super-instructions (1.1), linguist attributes for .dado and .dados
- rc.6 close: the release gate is green; the record says so
- rc.6 close: kill the mutation pass's survivors
- rc.6 close: the gate's findings (e2e groups, audits, grammar, doc words)
- rc.6 close: changelog dated, returns file released, docs regenerated; the work order becomes rc.7's (T72)
- rc.6: I99, an integer literal typed as a float computes as a float (f64 c = 7 / 2 is 3.5)
- rc.6: K8, lends, generics and read-only views
- rc.6: I98, a conversion's operand is its own expression (f64(7) / f64(2) is 3.5)
- rc.6: K5, constants: #len of a const, package windows, float conversions, p.K.w, a package's own -D
- rc.6: K4c, what a script writes into a lent slice or map reaches the sender
- rc.6: K4b, maps, matrices, #soa, wide strings, cstring and function values cross the seam
- rc.6: K4b, enums, distinct types and unions cross the seam
- rc.6: K27, a class embeds a type
- rc.6: K27, Vec2(1, 2) builds a type from its members, in both dialects
- rc.6: T70, Dado gains Vec2(1, 2) construction (Sam); planning sections deferred to the debrief
- rc.6: K27, script-declared type and union, checked by Dado's declaration code
- rc.6: K27, a lossy implicit narrowing warns once per site; a script's int no longer coerces to a Dado float
- rc.6: re-bless core:script's declarations snapshot
- rc.6: K27, int and float are Dado's types, adapting to the width they meet
- rc.6: K27, fixed arrays cross the seam as the same type (a break)
- rc.6: K27, fixed arrays [N]T in DadoScript, checked by Dado's code
- rc.6: K26, DadoScript's not-built refusals move into the dialect pass
- rc.6: K26, one type lowering for both dialects
- rc.6: re-bless script_lowered's phase snapshots; Q23 and Q24 answered (T68)
- rc.6: K26, the Venn coverage solver and its baseline (I91); the S0 audit
- rc.6: I90, a lowered script method's thunk marks ctx used (fixes -Werror)
- work order update
- rc.6: Q22 left open (the index and a library's test state); T62 keeps the README shape
- rc.6: T62 settled: CI opens an index pull request only when a release flips pass/fail
- rc.6: T62, the library README is the source the index mirrors
- rc.6: T61, every task says whether it needs an increment; the queue's Ships column
- rc.6: T59 amended (imports exact and lowercase, a did-you-mean help); T60 splits K25
- rc.6: T59, library names are case-insensitive everywhere (K25)
- rc.6: T58, an indexed library not on the device is a lint, fetched on request (K25)
- rc.6: T57, lib: is an ordinary collection; no compiler rename (T56's withdrawn)
- rc.6: T56, imports: becomes lib:, the index collections/lib/index.md
- rc.6: T55, the library index at collections/import/index.md
- rc.6: T53, dado new|init library|program (K15); T54, a library's versions and releases (K25)
- Revert the speculative packages section in dado-1.1.0.md (Sam was musing, not asking for a record)
- dado-1.1.0.md: dependencies between published libraries, routed issues and opt-in CI (Sam, speculative)
- rc.6: T52, a breaking release opens an issue on each library it breaks (K25)
- rc.6: T51, published libraries revalidated on a schedule (K25)
- rc.6: T50, the library index is one awesome-style Markdown file
- rc.6: T49, dado publish opens the index's pull request itself (K25)
- rc.6: K25, packages from git, scheduled optimistically at the lowest priority (T48)
- rc.6: Q21 answered (T47): packages from git with a curated name index
- rc.6: Q21, packages from git (Sam's restatement of CP-10), with what to rule
- rc.6 intake: I89, the last run's diagnostics kept and replayed in a TUI filtered by kind (T46, Sam)
- rc.6 intake: I88, terminal diagnostics capped at 12 with --log FILE (T45, Sam)
- CHANGELOG.md: a specific changelog, kept during each rc (T44)
- rc.6 intake: I87 (sawbox DI-0423), a false refusal rc.5's K3 introduced