feat(match): list patterns [head, ...tail] — the last production primitive

[MelbourneDeveloper]

TLDR

Lands list patterns ([] / [a, b] / [head, ...tail] / [a, b, ...rest]) in match — the last unshipped production-app primitive — and fixes the dev Language Server, which never launched because its configured compiler path pointed at the C-runtime archive directory instead of the built binary (so hover and every LSP feature were dead).

Details

Feature — list patterns ([TYPE-LIST-PATTERNS])

• Grammar: new list_pattern rule; scalar literals are split out of $.literal so [head, tail] can never collide with a two-element list literal. The index [ is now token.immediate, so a match-arm body (=> 0) no longer swallows the next arm's [...] as a postfix index.
• AST: Pattern::List { elements, rest }.
• Lowering (osprey-syntax), HM inference (osprey-types: unifies the scrutinee with List<E>, binds each element to E and ...rest to List<E>), free-variable analysis (osprey-codegen/freevars), and match codegen (osprey-codegen/pattern: length-guard ==/>=, then osprey_list_get / osprey_list_drop). Built over the pre-existing osprey_list_drop runtime.
• Examples: lists/list_basics.osp gains a section covering all four forms + a recursive sumList (Result-unwrapping the overflow-checked +). Two failscompilation cases reject mid-list rest ([a, ...m, b]) and double rest ([...a, ...b]).
• Documented limit: deep non-tail recursion is stack-bounded (no TCO yet) — fine for bounded recursive descent (JSON nesting); the examples stay shallow.

Fix — dev Language Server never launched (hover/def/refs/etc. all dead)

• Root cause: .vscode/settings.json set osprey.server.compilerPath to …/compiler/bin/osprey. compiler/bin is the gitignored C-runtime archive directory (lib*_runtime.a), not a binary — so the client spawned a nonexistent file and died with ENOENT, leaving the LSP in startFailed. The compiler that make build produces is target/release/osprey. Repointed the setting there and corrected the explanatory comment block (//4–//8, now noting compiler/bin is the C-runtime archive dir, NOT the binary).
• Hardening (vscode-extension/client/src/extension.ts): new looksLikePath(); resolveServerCommand() now detects a configured path that looks like a path but doesn't exist on disk, emits a showWarningMessage + output-channel warning, and falls back to the bundled compiler then bare osprey on PATH instead of silently spawning a dead path. makeClientFailureHandling() centralises the client's initializationFailedHandler/errorHandler so a failed start is logged and surfaced rather than swallowed.

Fix — editor Run/Compile ran a stale compiler; VSIX now self-contained

• The editor's Run/Compile commands previously execFile'd a bare osprey, which resolved to whatever stale global build sat on PATH (an old ANTLR-era binary that rejects [head, ...tail] with no viable alternative at input). Both now route through resolveServerCommand(context), so Run/Compile use the same version-matched compiler as the LSP.
• make _vsix_bundle now stages target/release/osprey plus the libfiber_runtime.a / libhttp_runtime.a C-runtime archives into bin/<platform>/, and .vscodeignore re-includes !bin/**. find_runtime_lib searches for the archives beside the executable, so the bundled compiler can link --run from inside the installed extension — proven end-to-end by running the bundled ~/.vscode/extensions/nimblesite.osprey-*/bin/darwin-arm64/osprey from a neutral cwd against the golden output. make rebuild-install-vsix rebuilds all binaries (make build → C archives + release compiler + extension compile) before packaging.

Coverage & tests

• vscode-extension gate raised to 89% in coverage-thresholds.json (measured 89.92%, 375/417 lines). The earlier toothless integration tests (if (result) assert; else log) passed even with hover broken — exactly how this bug shipped — so they were replaced with assertion-dense live-LSP tests run against the real built compiler.
• Rust coverage is now gated per crate (floor 95%; osprey-ast 96, osprey-cli 95, osprey-codegen 95, osprey-lsp 97, osprey-syntax 95, osprey-types 98, osprey-runtime-sys 99) — make _coverage_check_rust enforces every crate individually, backed by new unit tests across osprey-codegen, osprey-syntax and osprey-types.

Cleanup — docs/plans/ removed (completed/superseded design docs, recoverable from git history); the four spec links that pointed at it were repointed.

How Do The Automated Tests Prove It Works?

List patterns

• Differential golden suite (zsh crates/diff_examples.sh): PASS=47 FAIL=0 NOEXP=0, FC_OK. list_basics.osp byte-matches its .expectedoutput — classify over []/[10,20]/[1,2,3]/[7] yields empty/two(10,20)/many head=1 rest=2/one(7); sumList yields 6 and 55; restLen yields 1/0. list_pattern_middle_rest and list_pattern_double_rest are rejected (nonzero exit).
• examples_compile::every_tested_example_compiles_to_ir and ::list_pattern_negative_cases_are_rejected (osprey-cli).
• freevars::list_pattern_binds_prefix_and_rest_not_free proves head/tail/rest are bound, not captured by an enclosing closure.
• cargo test --workspace green; make _coverage_check_rust passes every per-crate gate (osprey-ast 97.1, osprey-cli 96.0, osprey-codegen 95.6, osprey-lsp 99.0, osprey-runtime-sys 100, osprey-syntax 95.8, osprey-types 99.0).

LSP + editor fix — vscode-extension suite (43 passing locally and in CI under xvfb), exercising the real language server against the freshly-built target/release/osprey:

• CHUNKY: full language-intelligence sweep over one program — over a single 10-line program asserts hover (fn area(r) -> Unit at decl and call site, builtin listLength -> int/List, print -> Unit), go-to-definition (area→line 1, perimeter→line 2), references (area 3× on lines [1,4,5], perimeter 2× on [2,6]), 10 document symbols with correct kinds (Shape=Class, area/perimeter=Function, radius=Variable), signature help (1 param, activeParameter 0), and completion (declared names + fn/let/match/type).
• CHUNKY: diagnostics lifecycle — broken source surfaces an Error diagnostic (source osprey, /syntax/i message, range), editing to valid clears it and hover returns, re-breaking re-raises it.
• CHUNKY: list-pattern program and CHUNKY: hover + symbols work on the ACTUAL reported list_basics.osp file — hover/def/refs/symbols/completion over the exact classify match in the file from the original bug report.
• Resolution unit tests: resolveServerCommand falls back and warns when the configured path is missing, keeps a bare command name without touching the filesystem, an existing configured path is still returned verbatim and never warns, looksLikePath distinguishes filesystem paths from bare commands.
• Failure-handler unit tests: initializationFailedHandler logs, surfaces an error, and stops retrying; errorHandler.error/.closed; deactivate stops the running language client without throwing.
• Regression guard (Committed Dev Settings Sanity): reads the committed .vscode/settings.json and asserts compilerPath is never the dead compiler/bin/osprey path, and that a checkout-local compilerPath resolves to a real, built binary ending in target/release/osprey.

CI — all 5 checks green on the head commit: Rust Compiler (fmt, clippy, test, differential), Test, Format, Build & Validate (lint + make test per-crate coverage + differential + vscode tests + build), Website E2E (Playwright), Windows Core Build & Smoke Test, Detect changed areas.