Skip to content

Releases

v1.0.0-rc.10.3

v1.0.0-rc.10.3 Pre-release
Pre-release

Choose a tag to compare

@dadolangcom dadolangcom released this 14 Nov 09:37

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) answered 0 whatever byte was declared to do, with no diagnostic, in rc.9 and every rc.10. Rename the function; for a foreign function, 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.
  • ERR0309 in a script: a bare string(…), int(…), float(…), print(…) or println(…) that a Dado function is also named as — one of the script's package, or one that import . 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 --release web 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_SEED is no longer needed for reproducible output.
  • dado build and dado check say 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 foreign constant or variable named as a type (C's name, which @c cannot 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

v1.0.0-rc.10.2 Pre-release
Pre-release

Choose a tag to compare

@dadolangcom dadolangcom released this 12 Nov 22:21

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 --release web 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 a project: package empty.)
  • A --release web page asked for every script the bundle had folded into registry.js: its manifest listed a js-module row 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 run and dado test with --target=web, a dev build and --release.
  • DadoScript: a store through an any that was not reached from a name was dropped, with no diagnostic. m[k].f = v, xs[i].f = v, g().f = v and handle.field.f = v (an any field 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 = v is accepted (rc.9: ERR0606): an any is 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()) was ERR0001 ("outside the slice the port builds so far"). An any is called through whatever expression answers it.
  • DadoScript: a store through a container or an any inside a parenthesised list of places ((xs[0], n) = (5, 1)) was dropped with no diagnostic. It is ERR0606, 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, a T or [N]T slot of another record or tuple, a {K: T}. The C had a second struct for T wherever 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 foreign block's flags "-Wno-X" was ignored, so a header that needs the clause did not compile under gcc: vendor:sokol/sokol_app on Linux stopped at "ISO C forbids conversion of object pointer to function pointer type". The header's #include is written between #pragma GCC diagnostic push, ignored "-WX" and pop again, as in rc.9.
  • A single-header library reached only through a package that names its header was read without its backend: sokol_gfx.h stopped at "Please select a backend with SOKOL_GLCORE, …", or was not found at all, in a program that reaches app:ui/grid and calls nothing vendor:sokol/sokol_gfx declares (dado test collections/app/ui, a headless program over app:ui). app:ui/grid names sokol_gfx.h to put it above its shader header; the define beside the binding itself (the backend, with its link) was dropped as unreached, and so was the -I of the package that holds the header. A block that declares nothing and carries a define, 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[:] or xs[..<n] where xs holds nothing yet wrote ptr + 0 on 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 &r loop into storage that outlives the frame, where the value holds no view of the frame (KNOWN[k] = r^ walking file.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 distinct types over one base, neither of them a generic parameter (make($L lane, VxId z, OrId outrec)): ERR0504, "binds the 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 does a * -1.0. Literal arms take the array's element type as a bare literal does, so integer arms beside a [3]f64 and float arms beside a [3]f32 are accepted too (rc.9: ERR0504).
  • Valid code the C compiler refused: a scope with a defer that ends by leaving, where every arm of an if/else or a switch ends 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 test wherever 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 the return, fail, break or continue that 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 226 into a const char[], which gcc refuses under -Werror where char is signed ("overflow in conversion from 'int' to 'char'"); clang and zig cc took it, and so did gcc on aarch64. Such a byte is written as a character constant ('\342'), the same byte under either sign of char;
    • the link named -lm before libquickjs.a and dropped the engine's own -lm after it as a repeat, so under GNU ld with --as-needed (gcc's default on Ubuntu) QuickJS's exp, cos, sqrt were undefined, in dado build, dado run and dado test --no-sanitize. A repeated -l word is kept at its last place.
  • The one-file C (--emit=c) of two builds did not compile under clang: a #NONE program whose runtime names fwrite only 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 types quickjs.h restates, a second time. The stand-ins are marked unused, and the engine stays a unit of its own, as in rc.9. Builds through dado were not affected.

v1.0.0-rc.10.1

v1.0.0-rc.10.1 Pre-release
Pre-release

Choose a tag to compare

@dadolangcom dadolangcom released this 10 Nov 22:21

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 #append added nothing, an assignment never happened, a call taking the conversion vanished, and return ([3]f64)(…) became a bare return;. 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 still ERR0201. A statement the checker can give no value without reporting why is now an internal error rather than silence.
  • f()^.method() on a ^self method was ERR0606 ("a value with no place"), and so was h().p^.bump(); a deref names existing storage, and the method changes it.
  • self in a ^self method is ^W again, 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 type W). As in rc.9, W c = self, take(self) for a W parameter and self = o are ERR0504 (write self^), self == nil is accepted, and fmt.println(self) prints the address.
  • Indexing a [1]cstring (and a [1] of a #c.* scalar, a function reference or a union) was ERR0001; it indexes as a run of one again. An index other than 0 on a value that is not a run (k[1] on an i32 or a cstring) is ERR0519 again (rc.10 accepted it).
  • Indexing through a pointer was not checked. p[i] on any ^T compiled to C pointer arithmetic, so p[2] on a ^ref []i32 read 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 slot 0 (ERR0519 for 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 ^const is a ^const (rc.10 gave a writable pointer). p[i] = c on a ^string8 is ERR0606, as on a string8.
  • cstring == and != were ERR0607; 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 through string8 for that.
  • #send of a constant composite value into a channel field (#send(q, 0, nil) into a ref []char8 field) wrote C that did not compile.
  • Web builds dropped a package's C sidecar and its exports. The manifest of a --target=web build lacked its source, include, header and c-export rows, so a package's .c files were neither compiled nor linked, and export functions were missing from the module. They are back, and each export is listed in the module's exports.
  • An export function that no Dado code calls was lost natively too: a dev build left it out of the executable's dynamic symbols, a --release build removed it, and an export in a collection package was never compiled. Every export is compiled and visible, as in rc.9.
  • dado test failed to link on its second run ("multiple definition") in any package with a .c sidecar, including vendor: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 as js:/… or ….js.js; and an import or export … from written over several lines kept its unlinked specifier. Modules are laid out under dados/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 (PointD and [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, so v.centroid is the whole array (rc.9 read its first element);
    • && and || with a const bool operand: ERR0504;
    • a constant expression as a case label (case 0 - 1:): ERR0901;
    • a slot name of a named-tuple result through an auto binding (auto r = f(), r.ok): ERR0410;
    • indexing through a pointer to a tuple (p[0].owner[i] with p a ^(^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) with LO an f32): ERR0504.
  • dado check missed errors in imported collection packages. Code in a package imported as project:x, vendor:x or another collection was diagnosed only where the program reached it, so dado check main could pass while checking the packages one by one found errors. dado check and 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 on any there, and missed LNT0412).

Changed

These were in rc.10 and are kept; they were missing from its notes.

  • dado build type-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. Run dado check to see errors in library code nothing calls yet.
  • A ref []T slot read through a ^const is a []const T: f(s^.positions[0..<2]) with ^const Soup s is ERR0504 for a []f32 parameter (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 i32 parameter is ERR0504, since a [1]T is a T (rc.9 accepted it). Pass a run ([2]i32 ids = …; set(ids[:])) or make the parameter a single value.
  • dado inspect --format=json names tuple slots in signatures: ([3]f64 a, f64 gap) (rc.9: ([3]f64, f64)).

v1.0.0-rc.10

v1.0.0-rc.10 Pre-release
Pre-release

Choose a tag to compare

@dadolangcom dadolangcom released this 09 Nov 21:34

Breaking

  • ERR0540: a string literal made a cstring holds no NUL. cstring s = "a\0b" compiled and handed C "a", the rest lost without a word, since C reads a cstring to its first NUL; it is refused now wherever a literal becomes a cstring — 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 a string8, string16 or string32, whose length counts the NUL as one more unit. Write the literal without the \0, or keep bytes that hold one in a string8 or a []char8 and pass its pointer and length.

Added

  • Copying into a run that already exists. A slice assignment copies an exact window: dst[i..<j] = src, and dst[:] = src for the whole run; the lengths must be equal, which is ERR0617 when 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's copy does. Either side is a fixed array, a window or a ref []T; the destination is a place (ERR0606 for 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, as memmove'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" in docs/language.md.
  • T(), the zero initializer: for a declared type T, the value T t with no initializer gets — each slot at its default, zero where it has none — written as an expression (return T(), f(T())). Where T t is 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 over f32 and f64 (#abs, #min and #max over integers too), lowered to what the target has (libm or a builtin in C, Math on 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:math is 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 is ERR0402). died.connect(f), died.disconnect(f) and died.emit(hp) in a script; from Dado through a handle g of the class, g.died.connect(f) with a package-level function, or g.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 (ERR1206 for one that cannot).

Changed

  • The compiler is self-hosted. dadoc and dado-lsp are 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.sh compiles bootstrap/dadoc.c (the compiler's own C), then the compiler builds itself; no Rust or cargo is needed. Release archives ship dado beside dadoc and dado-lsp, and install.sh (install.bat) runs dado install (old: dadoc bootstrap, which the new dadoc does not have); an install keeps collections/language, from which dado update rebuilds dado. dadoc --version names the version on its first line, as before, and self-hosted (tools/dadoc) on its second (old: Rust's commit, build date, rustc and zig lines); dado-lsp --version names 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/dadoc 11.8 s (57.5 s), and 19.3 s with --release (74.3 s); dado build tools/dado 3.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 behind ERR0803 and WRN0803 checks 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.
  • WRN0803 warns 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 check and 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-c keeps it, and dadoc --emit=c (on standard output when no -o is given) writes the one-file C for reading.
  • ERR1029 checks a foreign name against the C names the compiler now writes, not rc.9's dado_<pkg>_<name> and dado_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 the h header declares a readable typedef for 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; write n := #copy_into(into, from) (the count, the shorter length), or into[:] = from when the lengths are equal (an exact window; see "Copying into a run that already exists" in docs/language.md).
  • dadoc --emit= ast, types, views, h, narrowings, raises, strategies, crossings and placement: no tool, editor or check of the toolchain read them (h is the h extension of --emit=manifest, through tools/manifest/h.mjs).
  • dadoc serve, launch, bootstrap, --emit=build and --transpile-cache=, and its web-page writer: dado does 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

v1.0.0-rc.9 Pre-release
Pre-release

Choose a tag to compare

@dadolangcom dadolangcom released this 04 Nov 02:40

(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); ..s text 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

v1.0.0-rc.8.1 Pre-release
Pre-release

Choose a tag to compare

@dadolangcom dadolangcom released this 27 Oct 16:50

(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 warnings lists them
  • rc.8.1: the Windows installer keeps its window, retries, and keeps PATH variables

v1.0.0-rc.8

v1.0.0-rc.8 Pre-release
Pre-release

Choose a tag to compare

@dadolangcom dadolangcom released this 25 Oct 08:34

(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, ...
Read more

v1.0.0-rc.7.1

v1.0.0-rc.7.1 Pre-release
Pre-release

Choose a tag to compare

@dadolangcom dadolangcom released this 22 Oct 15:52

(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

v1.0.0-rc.7 Pre-release
Pre-release

Choose a tag to compare

@dadolangcom dadolangcom released this 22 Oct 00:44

(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

v1.0.0-rc.6 Pre-release
Pre-release

Choose a tag to compare

@dadolangcom dadolangcom released this 15 Oct 06:33

(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