aboutsummaryrefslogtreecommitdiff
path: root/src
Commit message (Collapse)AuthorAgeFilesLines
* lsp: initialize locals set under a found flag (definite assignment)work/uninit-localsGravatar zinc 12 days1-2/+2
|
* uninit: track aggregate fills per part, sticky computed-index fills, &a[k] ↵Gravatar zinc 12 days4-18/+51
| | | | and method calls set the aggregate; fix test/example hits; docs
* definite assignment: reading a local before it is initialized is a compile ↵Gravatar zinc 12 days13-81/+142
| | | | | | error (spec 4.1.5, b.1.9) track linited per local alongside the ownership state; snapshots, exit records and joins carry it, and a join keeps a local set only when every reaching path set it. x = e, a declaration initializer, &x (out-parameter), a full array initializer, or using an aggregate as an address set a local; field and element writes do not set the aggregate. while/for bodies that may run zero times do not count; do/while does. compiler, runtime, std, actor and lsp sources initialize the locals the rule flagged; zc0 accepts = {} brace lists (zeroed). tests: tests/errors/uninit_*.zc, tests/conformance/4-statements/uninit_*.zc
* js vm: syscall 7 (exit) stops the run with its status, so a runtime fault no ↵Gravatar zinc 12 days1-1/+4
| | | | longer runs on past the fault (js vm trace check)
* duplicate case labels are an error (b.2.15); unterminated string literal ↵Gravatar zinc 12 days3-8/+24
| | | | reported where it starts (b.2.11); an unreachable droppable cycle drops whole in one collection (6.15.3)
* constant expressions: c precedence and / % ^ (b.1.3); local const usable in ↵Gravatar zinc 12 days4-23/+90
| | | | constant expressions (b.1.7, b.2.16); zc0 matches
* fix: bytes test read one byte past the fixed map into the heapGravatar zinc 12 days1-0/+1
| | | | | | | | | rt.MW is the end of the fixed map (PW) since the growing heap landed; the heap starts right there, so ld16(addr_b(rt.MW)-1) read the heap's first byte: 0 on the default map by luck, 0x40 on the small map (16384). Probe the real byte-op bound instead: core answers syscall(9,10) with the host reservation MW; micro ports, whose bound is their memory size, fall back to syscall(9,0).
* merge work/demo-fixes: analyzer ownership fixes (back links, loop-built ↵Gravatar zinc 12 days6-13/+141
|\ | | | | | | lists, .u inference), Io.print any args, block-end borrow messages
| * prescan: guess an owned return only from a local declared from new/heap, not ↵Gravatar zinc 12 days1-2/+6
| | | | | | | | a global assigned one (fixes lsp self-check); xref baseline for the new writers
| * analyzer: a .u (declared or inferred) function can't return a borrowed ↵Gravatar zinc 12 days2-1/+9
| | | | | | | | parameter or a value derived from one; fixtures
| * std.Io.print/println take any mix of printable arguments (compiler expands ↵Gravatar zinc 12 days2-6/+40
| | | | | | | | per type); docs, conformance
| * analyzer: a back link (container's owner stored into it) stays a plain ↵Gravatar zinc 12 days1-1/+4
| | | | | | | | reference, fixing a compile hang on a<->b and a leak; ending an owner kills its owned children too (fixes use after reassigning a container); escape fixtures
| * analyzer: infer .u from returns of fresh objects in the body (prescan guess, ↵Gravatar zinc 12 days2-1/+38
| | | | | | | | then checked as .u)
| * analyzer: an outer owner moved into a deeper container can take it back ↵Gravatar zinc 12 days3-4/+46
| | | | | | | | (loop-built lists); block-end frees name the owner (why 9) in messages and LSP related info
* | hold: copy hold.h with micro.c everywhere; xref baseline for hold globals; ↵Gravatar zinc 12 days5-7/+19
| | | | | | | | lsp keyword completion yields to a same-named symbol; compiler message avoids the word actor
* | lsp: hold and shared hovers, completion of the keywords, shared variables ↵Gravatar zinc 12 days1-1/+9
| | | | | | | | marked in hover and completion; tmLanguage keywords; hold_lsp_test.js
* | hold blocks: top-level hold { shared let ...; fn ... } monitors; shared ↵Gravatar zinc 12 days6-3/+208
| | | | | | | | values kept by the host and copied in/out at the outermost call, reentrant per-block locks in declaration order (core, micro)
* | actors: micro workers map a copy-on-write snapshot too; inherited input is ↵Gravatar zinc 12 days3-15/+113
| | | | | | | | only the unread bytes; worker stacks 4 MB
* | actors: remaining tls tables and the input buffer allocated on use; a worker ↵Gravatar zinc 12 days2-19/+47
| | | | | | | | inherits only unread input
* | actors: large per-thread compiler tables mapped on first use instead of ↵Gravatar zinc 12 days1-18/+75
| | | | | | | | static tls (13 MB of every worker's stack mapping)
* | actors: worker memory is copy-on-write against a snapshot of the parent ↵Gravatar zinc 12 days1-10/+100
| | | | | | | | (memfd/shm), o3 entry tables handed over sparse
* | boot: build the compiler from a pinned wasm seed (seed/zc.wasm, WASI) under ↵Gravatar zinc 12 days6-0/+286
|/ | | | wasmtime or node, proven by the fixpoint; seed/MANIFEST hashes; make seed; legacy c bootstrap kept as make genome-c
* mkgenome: on a header mismatch name FTOP/ZFP, print the image's and the ↵Gravatar zinc 12 days1-6/+24
| | | | map's values, and point at a stale src/runtime/rt.zc or map
* lsp: borrow errors ranged on the use, with related information for where the ↵Gravatar zinc 12 days3-4/+54
| | | | owner ended and was declared; vscode client passes relatedInformation through
* analyzer: check borrow returns of forward-called functions at the unit's ↵Gravatar zinc 12 days6-9/+115
| | | | end; borrows clause for prototypes, definitions, externs and function types, checked against the body
* analyzer: use-after-end messages name the borrower, the owner and how the ↵Gravatar zinc 12 days4-18/+47
| | | | owner ended (freed, moved, .d parameter, push, global, reassignment), with fixtures
* lsp: prefer the rt import fix when a library group wraps the same nameGravatar zinc 12 days1-1/+2
|
* lsp: complete a module path one level at a time (std. lists groups, ↵Gravatar zinc 12 days1-4/+24
| | | | std.File. and std.Io. their members)
* std: add std.Io (print, println, nl, put_*, put_f, get_c, eof, read, ↵Gravatar zinc 12 days2-2/+80
| | | | getline) with test, learn example and docs
* x86-64 jit: inline new_k, recycle_leaf and own fast paths, in o3 regions and ↵Gravatar zinc 13 days3-5/+216
| | | | | | | | | | | | | | plain blocks a call to rt.new_k / rt.recycle_leaf with a constant class, or to rt.own, does its class-list pop or push (or owner store) inline and goes on after the call; an empty list, memdebug, a held range, a block outside memory, a translated word or a type/class mismatch takes the ordinary call. in a region this replaces the o3_invoke round trip. o3 frees of leaf objects now use recycle_leaf too (new_k stamps the type inside o3 since b86db60). ZYNOFASTALLOC=1 turns it off; ZYPERFMAP=1 writes a perf map of translated code. tests/programs/o3_freelist.zc: reuse, zeroing, an empty list, untyped neighbours, memdebug; jit vs ZYNOFASTALLOC vs ZYO3INTERP.
* rt: recycle, new_k and own without helper calls or || chainsGravatar zinc 13 days1-18/+58
| | | | | | | | | | perf (ZYPERFMAP) on plain trees new/free showed recycle, new_k and own taking about 70% of the time, mostly in calls to isobj, paylen, bdrop, bclass and fpush and in the truth values plain code builds for && and ||. recycle writes isobj, paylen and the class-list push out, calls scan_ptr only for 8 or more words left, and own and new_k test with nested ifs. frame_control grows to 22 words: a tag, &dbg and the entries of new_k, recycle_leaf and own for the x86-64 jit's inline fast paths (next commit).
* find_replace: cover o3 function prologues on every backendGravatar zinc 13 days1-7/+44
| | | | | | | | arm64, llvm and the region-interpreter rdrop path now watch the two prologue words the way the x86-64 jit already did, so icon.replace_function's lit+jmp patch retires a compiled callee (and clears fn_nat) instead of leaving a stale stub. three new icon regressions: repeated o3 replace, failed publication keeps the old entry, and a direct call after warming the region.
* prover: do not restore length facts after a call-loopGravatar zinc 13 days1-6/+6
| | | | | | | Restoring undirtied lafacts when the body might free was wrong: push can grow an array without dirtying its name, so a[99] after push warned against a stale length 0. Keep the old lafact_keep rule; reorder explain_prover so the constant/affine cases run before the touch() loops.
* prover: len/cross-array/fixed-new/affine proofs; keep facts past call loopsGravatar zinc 13 days1-19/+27
| | | | | | | | Rebased the prover WIP onto main. lafact_keep restores undirtied allocation facts even when the loop body might free (so a later touch() no longer drops every length fact). proven_p uses ptr_still so an outer call keeps the check. entry_fact still supplies the size for the "might free" explain reason. bounds_prover.zc and explain_prover.zc land with test.sh coverage.
* wip: prover gaps (inline len bound, cross-array, rt.new depth, fixed new, ↵Gravatar zinc 13 days4-42/+112
| | | | affine i*n+k); unbuilt and untested
* o3: use new_k (size-class free lists) like plain codeGravatar zinc 13 days1-4/+4
| | | | | | | Constant-size typed new inside o3 now calls rt.new_k instead of always taking new_t/new_raw. new_k and recycle_leaf skip the o3 argument-fatten path the way free/recycle already do. trees o3 new/free on the x86-64 jit dropped from about 4.1 ms to about 2.7 ms per iter (matches plain).
* x86-64 o3: direct o3-to-o3 calls (rcall_x64 / rfinish_x64)Gravatar zinc 13 days1-14/+182
| | | | | | | | | Port arm64's rcall/rfinish to the x86-64 region jit: call the callee's entry stub through fn_nat with a built frame, return via linkstk, and fall back to o3_invoke when the stub is missing or the frame/depth check fails. Clear fn_nat on rforget and cover the function prologue so icon.replace_function drops the region (o3_caller_replace). vm_until saves jit_depth around nested bytecode, matching arm64.
* actor: a declared actor without its own drop gets one that awaits owed ↵Gravatar zinc 13 days2-3/+16
| | | | replies and closes the endpoint; the handler reaches the struct through endpoint.state so the struct isn't shared; spawn hint skips mailbox structs
* std: File, the first user of drops: std.Host.open(path, mode) returns an ↵Gravatar zinc 13 days1-5/+33
| | | | owned std.File (or null) with write and read, and its drop closes the descriptor; Host.writefile is built on it; file_drop.zc, learn and readme
* rt: gc_drops finalizes a droppable value that reaches itself (a cycle, or a ↵Gravatar zinc 13 days1-3/+9
| | | | drop capturing its own value), one per collection, each once; before, each waited for the other forever; spec 6.15.3, drop_gc_cycle.zc, drop_gc_self_capture.zc, design doc lists what landed
* o3: an o3 function called from normal code as a receiver method (run.method) ↵Gravatar zinc 13 days1-1/+3
| | | | enters and leaves the region and fattens its result, like a direct call; spec 4.10.3, o3_receiver_method_enter.zc
* o3: break and continue out of an o3 { } block call rt.o3_leave for each ↵Gravatar zinc 13 days1-0/+12
| | | | block they leave (the loop records the o3 depth it began at), so the depth returns to 0 and pending collections and drops run; spec 4.10.3, o3_break_continue_leave.zc
* rt: memreport marks a leaked value whose drop never ran with (drop); spec ↵Gravatar zinc 13 days1-1/+3
| | | | 4.11, readme, memdebug_report_drop.zc
* destructors: hint: x: has drop and is live at spawn; the worker's copy drops ↵Gravatar zinc 13 days2-0/+14
| | | | it too, on x.spawn() of a mailbox struct for each live owned local with a drop; spec 6.15.4, lsp hint check
* destructors: nothing moves out of a value with a drop: pop on an array with ↵Gravatar zinc 13 days1-1/+8
| | | | a drop, or on an array field of a value with a drop, is error: a: can't move out of a value with drop (fields were already borrowed projections); spec 6.15.5, four conformance programs
* destructors: reassigning an m owner that still holds a value frees the old ↵Gravatar zinc 13 days3-4/+43
| | | | value first, running its drop (right side first, then the free, then the store), with hint: x: reassigning frees the old value; a new value that is part of the old one is an error; u, d and captured owners keep the leak error; the new value's size, leaf type and drop are recorded like a declaration's; spec 6.8.5, 6.15.2
* genmap: default genome reservation 0x70000 words (the genome had 197 words ↵Gravatar zinc 13 days2-10/+10
| | | | left); the map constants in rt.zc and the README table move by 0x8000; gc.zc's reclaim bound is 900 (937 with the heap higher, 952 before) and the run-only section rewrites whatever its number
* compiler: a //:lines marker starts a new file, so unbounded; and unchecked; ↵Gravatar zinc 13 days1-1/+3
| | | | of the source before it end there: a program joined to the unbounded runtime in a self-hosted run-only image is bounds-checked again (since d55b5fd its index errors went unreported); runtime_image_test expects the trap's exit status 2; spec 4.15.1, 4.x unchecked, 5.15.3
* compiler: the drop globals' comment says mailbox send, so nothing the ↵Gravatar zinc 13 days1-1/+1
| | | | compiler reads mentions actors (test.sh check)
* rt: the free paths take one F_HASDROP test, and dropfree does the drop and ↵Gravatar zinc 13 days1-4/+4
| | | | the clearing out of line