diff --git a/.claude/skills/code-dedup/SKILL.md b/.claude/skills/code-dedup/SKILL.md
index 2032a9b6..f2a05bcf 100644
--- a/.claude/skills/code-dedup/SKILL.md
+++ b/.claude/skills/code-dedup/SKILL.md
@@ -1,109 +1,70 @@
---
name: code-dedup
-description: Searches for duplicate code, duplicate tests, and dead code, then safely merges or removes them. Use when the user says "deduplicate", "find duplicates", "remove dead code", "DRY up", or "code dedup". Requires test coverage — refuses to touch untested code.
+description: Finds duplicated code and dead code with deslop, then merges or removes the worst of it. Use when the user says "deduplicate", "find duplicates", "remove dead code", "DRY up", or "code dedup".
---
# Code Dedup
-Carefully search for duplicate code, duplicate tests, and dead code across the repo. Merge duplicates and delete dead code — but only when test coverage proves the change is safe.
+Find duplication with **deslop**, then use judgement to merge only what is worth merging.
-## Prerequisites — hard gate
+## Judgement first
-Before touching ANY code, verify these conditions. If any fail, stop and report why.
+Deslop measures structural repetition. It cannot tell whether collapsing two blocks makes the code better or worse. **You decide.** A report with 476 clusters does not mean 476 edits — it means the five or ten that matter. `merge-plan` returns verdict `ai_or_human` for anything non-mechanical: that is the tool handing you the call.
-1. Run `make test` — all tests must pass. If tests fail, stop. Do not dedup a broken codebase.
-2. Run `make test` — tests are fail-fast AND enforce the coverage threshold from `coverage-thresholds.json`. If anything fails, stop and fix it before deduping.
-3. Verify the project uses **static typing**:
- - Rust (crates/, tree-sitter-osprey/): typed by default — proceed
- - TypeScript (vscode-extension/, webcompiler/, website/): check `tsconfig.json` has `"strict": true` — proceed if yes
- - C (compiler/runtime/): typed by default — proceed
+**Merge** real copy-pasted logic — a block differing only in a symbol or a literal, 3+ near-identical call sites, one algorithm restated in two modules.
-## Steps
+**Leave** anything else, especially:
-Copy this checklist and track progress:
+- **Data, not logic** — constant tables, per-platform SDK/triple/runtime arms, doc rows. Merging buries the values the reader came for.
+- **Structural coincidence** — `structural_only` CST walks and `match` shapes: same skeleton, different meaning.
+- **Already factored** — only thin wrappers remain over a real helper.
+- **Merges needing a new bool/enum parameter** to make one function do two jobs.
-```
-Dedup Progress:
-- [ ] Step 1: Prerequisites passed (tests green, coverage met, typed)
-- [ ] Step 2: Dead code scan complete
-- [ ] Step 3: Duplicate code scan complete
-- [ ] Step 4: Duplicate test scan complete
-- [ ] Step 5: Changes applied
-- [ ] Step 6: Verification passed (tests green, coverage stable)
-```
-
-### Step 1 — Inventory test coverage
-
-Before deciding what to touch, understand what is tested.
-
-1. Run `make test` to confirm green baseline. `make test` is fail-fast AND enforces the coverage threshold from `coverage-thresholds.json` (REPO-STANDARDS-SPEC [TEST-RULES], [COVERAGE-THRESHOLDS-JSON]). It exits non-zero on any test failure OR coverage shortfall.
-2. Note the current coverage percentage — this is the floor. It must not drop.
-3. Identify which files/modules have coverage and which do not. Only files WITH coverage are candidates for dedup.
+A wrong merge is worse than a duplicate.
-### Step 2 — Scan for dead code
+## Tools
-Search for code that is never called, never imported, never referenced.
+Prefer the MCP — live index, no rescan cost:
-1. Look for unused exports, unused functions, unused variables
-2. Use language-appropriate tools:
- - Rust: `dead_code`/`unused_*` are denied workspace-wide, so `cargo clippy --all-targets` reports unused code as errors
- - TypeScript: check for `noUnusedLocals`/`noUnusedParameters` in tsconfig, look for unexported functions with zero references
- - C: compiler warnings for unused functions/variables (already caught by `-Wall -Wextra`)
-3. For each candidate: **grep the entire codebase** for references (including tests, scripts, configs). Only mark as dead if truly zero references.
-4. List all dead code found with file paths and line numbers. Do NOT delete yet.
+| Tool | Use |
+|---|---|
+| `mcp__deslop__duplicates` | **Start here.** Clusters worst-first by `mass`. `{detail:"summary", limit:20}`; `include_per_file:true` for a per-file table, `path_contains` to scope. |
+| `mcp__deslop__cluster-by-id` | Every occurrence path + byte range for one `id`. |
+| `mcp__deslop__compare-pair` | The **only** pair evidence: two `{path,start_byte,end_byte}` in, `text_identity` and `structural` out. |
+| `mcp__deslop__merge-plan` | Mechanical plan for a cluster. `ai_or_human` → hand-edit. |
+| `mcp__deslop__find-similar` | Call **before writing new code** (CLAUDE.md mandates it). |
+| `mcp__deslop__rescan` | Refresh after edits. |
-### Step 3 — Scan for duplicate code
+A cluster's `kind` is the *weakest* pair against the canonical — **never assume two members match each other**. `compare-pair` the exact ranges you intend to merge.
-Search for code blocks that do the same thing in multiple places.
+No MCP? Use the installed CLI — what `make _deslop` runs:
-1. Look for functions/methods with identical or near-identical logic
-2. Look for copy-pasted blocks (same structure, maybe different variable names)
-3. Look for multiple implementations of the same algorithm or pattern
-4. Check across module boundaries — duplicates often hide in different packages
-5. For each duplicate pair: note both locations, what they do, and how they differ (if at all)
-6. List all duplicates found. Do NOT merge yet.
-
-### Step 4 — Scan for duplicate tests
-
-Search for tests that verify the same behavior.
-
-1. Look for test functions with identical assertions against the same code paths
-2. Look for test fixtures/helpers that are duplicated across test files
-3. Look for integration tests that fully cover what a unit test also covers
-4. List all duplicate tests found. Do NOT delete yet.
-
-### Step 5 — Apply changes (one at a time)
+```bash
+deslop . --nohtml --nojson --output "$PWD/target/deslop-report" --log-to-console --log-level error --no-color
+```
-For each change, follow this cycle: **change → test → verify coverage → continue or revert**.
+Exit `3` means over the ceiling in `.deslop.toml`. Check `deslop --version`; install from only if the binary is missing, matching the version pinned in `.github/workflows/ci.yml`. Never upgrade to move a number — the MCP server (`tool_version: 0.0.0-dev`) and the pinned CLI disagree, so **find** with the MCP and **measure** with `make _deslop`.
-#### 5a. Remove dead code
-- Delete dead code identified in Step 2
-- After each deletion: run `make test` (fail-fast + coverage + threshold all in one)
-- If `make test` exits non-zero (test failure OR coverage drop): **revert immediately** and investigate
+## The ratchet
-#### 5b. Merge duplicate code
-- For each duplicate pair: extract the shared logic into a single function/module
-- Update all call sites to use the shared version
-- After each merge: run `make test`
-- If tests fail: **revert immediately**
+**CI must never allow duplication to increase.** `max_duplication_percent` is a ratchet, not a budget.
-#### 5c. Remove duplicate tests
-- Delete the redundant test (keep the more thorough one)
-- After each deletion: run `make test`
-- If coverage drops below threshold, `make test` exits non-zero — **revert immediately**
+- **Never raise it.** Over the ceiling means you added duplication — remove it. The number is not the thing to edit.
+- **Lower it after every round** to the fresh `make _deslop` measurement. Slack above the measurement lets the next clone land free.
+- **A branch may not measure above `main`** — compare with the *same* CLI version, or the version gap alone will convict or exonerate falsely.
+- `.deslop.toml`'s comment block records the ratchet history. Extend it when you lower the ceiling; if that history and the live value disagree, someone raised it — **report a gate violation**.
-### Step 6 — Final verification
+## Process
-1. Run `make lint` — all linters must pass
-2. Run `make test` — tests must pass AND coverage must remain ≥ the baseline from Step 1
-3. Report: what was removed, what was merged, final coverage vs baseline
+- **Baseline.** `make _deslop` — record the percentage you start from.
+- **Gather.** `mcp__deslop__duplicates`, worst first. `cargo clippy --all-targets --all-features` is the whole dead-code scan (`dead_code`/`unused_*` are denied workspace-wide); grep the repo before deleting anything it flags.
+- **Triage.** Apply the judgement above. Record each keeper's two locations and intended helper, and each rejection's reason so nobody re-litigates it. `.deslop.toml` scopes the gate *by path*, so inline `#[cfg(test)]` and `#[path = "…"]` modules still inflate the number — an artifact, not a task.
+- **Apply.** One merge at a time, smallest diff that removes the duplication. Keep public and `pub(crate)` signatures intact so no caller has to change.
+- **Verify.** `make lint`, then `make _deslop`. Report what merged, what you left and why, and duplication vs baseline.
## Rules
-- **No test coverage = do not touch.** If a file has no tests covering it, leave it alone entirely.
-- **Coverage must not drop.** The coverage floor from Step 1 is sacred.
-- **One change at a time.** Make one dedup change, run tests, verify coverage.
-- **When in doubt, leave it.** If two code blocks look similar but you're not 100% sure they're functionally identical, leave both.
-- **Preserve public API surface.** Do not change function signatures or exported names.
-- **Three similar lines is fine.** Only dedup when the shared logic is substantial (>10 lines) or when there are 3+ copies.
+- **Three similar lines is fine** — merge at >10 shared lines or 3+ copies.
+- **Edit in place.** Never leave a parallel version of anything behind.
+- **When in doubt, leave it.**
diff --git a/.gitignore b/.gitignore
index d36c1751..9439014d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -141,6 +141,11 @@ benchmarks/cases/**/*.o
/tests/regressions/basics/files/test_output.txt
/tests/regressions/basics/files/test_stale_reason.txt
/tests/regressions/effects/osprey_http_state_levels.db
+# The injected disk handler in storage_injection.test.{osp,ospml} writes the
+# notebook and its archive. Each flavor owns its own names so the twins cannot
+# race when the corpus runs them concurrently from the same directory.
+/osprey_storage_injection_*.txt
+/tests/effects/injection/osprey_storage_injection_*.txt
# Core dumps from a crashed C test binary (a container run leaves them here).
core
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 57449b1a..33efe241 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -30,7 +30,7 @@
"rust-analyzer.check.allTargets": true,
"basilisk.enabled": true,
"basilisk.uv.enabled": true,
- "deslop.topOffenders.groupBy": "type",
+ "deslop.topOffenders.groupBy": "kind",
"deslop.embedding.provider": "ollama",
"deslop.embedding.model": "nomic-embed-text",
"deslop.embedding.mode": "auto"
diff --git a/CLAUDE.md b/CLAUDE.md
index f62b02f0..6ad38eab 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -70,6 +70,16 @@ Silently-wrong output is worse than a crash: a panic is found in seconds; a sile
- If removing an annotation still compiles with identical output, it was redundant — remove it. Applies to every `.osp` you touch: `tests/regressions/`, `benchmarks/`, docs and website snippets.
- **No consecutive print calls** — consolidate into one interpolated string.
+```ospml
+ // This is wrong because the signature can be inferred. You must omit this!
+ escape : string -> string
+ escape s =
+ bslash = "\\"
+ quote = "\""
+ step = replace s bslash (bslash + bslash) ?: ""
+ escapeControls (replace step quote (bslash + quote) ?: "") 1
+```
+
## Rust
- **Panics are illegal** outside the broken-code quarantine. Return `Result`.
diff --git a/Cargo.toml b/Cargo.toml
index 86fa01f5..bdfbabd0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -67,6 +67,13 @@ unused_variables = "deny"
unused_mut = "deny"
unused_assignments = "deny"
unused_results = "deny"
+# A `pub` item not reachable from the crate root is invisible outside the crate,
+# so `dead_code` never evaluates it and it can rot forever. Forcing `pub(crate)`
+# puts every such item back under the dead-code lint. [LINTS-DEADCODE-REACH]
+unreachable_pub = "deny"
+unused_lifetimes = "deny"
+unused_macro_rules = "deny"
+unused_qualifications = "deny"
trivial_casts = "deny"
trivial_numeric_casts = "deny"
elided_lifetimes_in_paths = "deny"
diff --git a/Makefile b/Makefile
index 4e544dda..db9cf423 100644
--- a/Makefile
+++ b/Makefile
@@ -279,6 +279,7 @@ lint: _deslop _lint
_lint: $(EXT_NODE_DEPS)
@echo "==> Linting..."
node scripts/verify-node-deps-guard.mjs
+ node scripts/verify-no-dead-code.mjs
cargo fmt --all --check
cargo clippy --workspace --all-targets -- -D warnings
cd $(EXT_DIR) && npm run lint
@@ -288,6 +289,12 @@ _lint: $(EXT_NODE_DEPS)
# threshold live in that committed config — the single source of truth. When
# the `deslop` binary is absent this target FAILS: a gate that cannot run must
# not report success. CI enforces the same ceiling through the official action.
+# Version of the deslop CLI `make setup` installs. MUST equal the `version:` the
+# Deslop action pins in .github/workflows/ci.yml — deslop measures source text,
+# so a different build can report a different percentage for the SAME tree, and
+# a local gate that disagrees with the merge gate is worse than no local gate.
+DESLOP_VERSION ?= 0.27.0
+
_deslop:
@echo "==> Duplication gate (deslop)..."
@if ! command -v deslop >/dev/null 2>&1; then \
@@ -301,7 +308,14 @@ _deslop:
deslop . --nohtml --nojson --output $(CURDIR)/target/deslop-report --log-to-console --log-level error --no-color
## hawk: Dead-code gate (astral-sh/hawk). Fails the build when any `pub`
-## declaration is unreachable from the osprey binary (hawk::dead_public). Scoped
+## declaration is unreachable from the osprey binary (hawk::dead_public).
+##
+## hawk counts the workspace's TEST binaries as reachability roots, so an item
+## whose only callers are its own `#[cfg(test)]` module passes this gate — that
+## is how `osprey_debug::DebugBuild` and `osprey_syntax::dependency_sets` lived
+## in the tree. `scripts/verify-no-dead-code.mjs` (run by `_lint`) answers the
+## narrower question "does PRODUCT code name this?" and catches that class.
+## Neither gate subsumes the other; both run. Scoped
## to dead_public ONLY — unnecessary_public / restricted-visibility findings are
## over-exposure, not dead code, and several are irreducibly public for the
## integration tests under this workspace's `dead_code = "deny"` policy, so they
@@ -407,6 +421,7 @@ setup: $(EXT_NODE_DEPS) $(WEBCOMPILER_NODE_DEPS) $(WEBSITE_NODE_DEPS)
@echo "==> Setting up development environment..."
rustup component add rustfmt clippy llvm-tools-preview
command -v cargo-llvm-cov >/dev/null 2>&1 || cargo install cargo-llvm-cov
+ command -v deslop >/dev/null 2>&1 || DESLOP_VERSION=$(DESLOP_VERSION) bash scripts/install-deslop.sh
@echo "==> Setup complete. Run 'make ci' to validate."
# ---------------------------------------------------------------------------
diff --git a/compiler/runtime/test_cmake_integration.sh b/compiler/runtime/test_cmake_integration.sh
deleted file mode 100755
index 8f4052d0..00000000
--- a/compiler/runtime/test_cmake_integration.sh
+++ /dev/null
@@ -1,60 +0,0 @@
-#!/bin/bash
-
-echo "🔧 CMake C Test Integration Verification"
-echo "========================================="
-echo "⚠️ This script must be run inside the VS Code Dev Container"
-echo " Use Command Palette → 'Dev Containers: Rebuild Container'"
-echo ""
-
-# Navigate to runtime directory
-cd "$(dirname "$0")"
-
-# Clean and create build directory
-echo "📁 Setting up build directory..."
-rm -rf build
-mkdir -p build
-cd build
-
-# Configure with CMake
-echo "⚙️ Configuring CMake..."
-cmake .. -DCMAKE_BUILD_TYPE=Debug
-
-if [ $? -ne 0 ]; then
- echo "❌ CMake configuration failed!"
- exit 1
-fi
-
-echo "✅ CMake configuration successful!"
-
-# Build the tests
-echo "🔨 Building C runtime tests..."
-make -j$(nproc)
-
-if [ $? -ne 0 ]; then
- echo "❌ Build failed!"
- exit 1
-fi
-
-echo "✅ Build successful!"
-
-# List available tests
-echo "📋 Available CTest tests:"
-ctest --show-only=json-v1 | jq -r '.tests[].name' 2>/dev/null || ctest -N
-
-# Run tests with CTest
-echo "🧪 Running CTest..."
-ctest --verbose
-
-if [ $? -eq 0 ]; then
- echo "✅ All C runtime tests passed!"
- echo ""
- echo "🎉 VS Code Integration Ready!"
- echo " - Open this project in VS Code with Dev Container"
- echo " - Go to Test Explorer (flask icon in sidebar)"
- echo " - You should see 'SystemRuntimeTests' and 'FiberRuntimeTests'"
- echo " - Click the play button to run individual tests"
- echo " - Use debug button to debug tests with breakpoints"
-else
- echo "❌ Some tests failed!"
- exit 1
-fi
\ No newline at end of file
diff --git a/compiler/runtime/test_http_runtime.sh b/compiler/runtime/test_http_runtime.sh
deleted file mode 100755
index f50d112f..00000000
--- a/compiler/runtime/test_http_runtime.sh
+++ /dev/null
@@ -1,80 +0,0 @@
-#!/bin/bash
-
-# Test script for HTTP runtime
-echo "🧪 Compiling and testing HTTP runtime..."
-
-# Compile all the runtime modules and tests
-echo "📦 Compiling runtime modules..."
-
-# Detect OpenSSL paths cross-platform
-OPENSSL_CFLAGS=""
-OPENSSL_LDFLAGS="-lssl -lcrypto"
-
-# Try to find OpenSSL include/lib directories
-if [ "$(uname)" = "Darwin" ]; then
- # macOS with Homebrew
- for path in "/opt/homebrew/opt/openssl@3" "/usr/local/opt/openssl@3" "/opt/homebrew/opt/openssl" "/usr/local/opt/openssl"; do
- if [ -d "$path" ]; then
- OPENSSL_CFLAGS="-I${path}/include"
- OPENSSL_LDFLAGS="-L${path}/lib -lssl -lcrypto"
- break
- fi
- done
-elif [ "$(uname)" = "Linux" ]; then
- # Linux - usually in standard locations
- if pkg-config --exists openssl 2>/dev/null; then
- OPENSSL_CFLAGS="$(pkg-config --cflags openssl)"
- OPENSSL_LDFLAGS="$(pkg-config --libs openssl)"
- fi
-fi
-
-gcc -c http_shared.c -o http_shared.o -pthread $OPENSSL_CFLAGS
-gcc -c http_client_runtime.c -o http_client_runtime.o -pthread $OPENSSL_CFLAGS
-gcc -c http_server_request.c -o http_server_request.o -pthread $OPENSSL_CFLAGS
-gcc -c http_server_response.c -o http_server_response.o -pthread $OPENSSL_CFLAGS
-gcc -c http_server_runtime.c -o http_server_runtime.o -pthread $OPENSSL_CFLAGS
-gcc -c websocket_client_runtime.c -o websocket_client_runtime.o -pthread $OPENSSL_CFLAGS
-gcc -c websocket_server_runtime.c -o websocket_server_runtime.o -pthread $OPENSSL_CFLAGS
-
-if [ $? -ne 0 ]; then
- echo "❌ Runtime compilation failed!"
- exit 1
-fi
-
-echo "🧪 Compiling test suite..."
-gcc -o test_http_runtime http_runtime_tests.c \
- http_shared.o \
- http_client_runtime.o \
- http_server_request.o \
- http_server_response.o \
- http_server_runtime.o \
- websocket_client_runtime.o \
- websocket_server_runtime.o \
- -L/usr/local/lib -lfiber_runtime \
- -pthread $OPENSSL_CFLAGS $OPENSSL_LDFLAGS
-
-if [ $? -ne 0 ]; then
- echo "❌ Test compilation failed!"
- exit 1
-fi
-
-echo "✅ Compilation successful!"
-echo ""
-
-# Run the tests
-echo "🚀 Running HTTP runtime tests..."
-echo ""
-./test_http_runtime
-
-if [ $? -ne 0 ]; then
- echo "❌ Tests failed!"
- exit 1
-fi
-
-echo ""
-echo "🎉 All tests passed! HTTP runtime is working correctly."
-
-# Clean up
-rm -f *.o test_http_runtime
-
-echo "✅ Test cleanup complete."
diff --git a/crates/osprey-ast/src/doc.rs b/crates/osprey-ast/src/doc.rs
index 71add3bb..cdf16816 100644
--- a/crates/osprey-ast/src/doc.rs
+++ b/crates/osprey-ast/src/doc.rs
@@ -83,13 +83,6 @@ impl DocComment {
}
}
- /// A summary-only outer doc — the common case, and the shape a bare doc
- /// comment with no recognised sections lowers to.
- #[must_use]
- pub fn summary_only(summary: impl Into) -> DocComment {
- Self::new(summary, String::new(), DocScope::Outer)
- }
-
/// Render the whole doc comment as the Markdown block a hover shows: the
/// summary, the body, then each populated section as a heading. `[Symbol]`
/// links are preserved verbatim so the LSP client renders them as links.
@@ -170,7 +163,7 @@ mod tests {
#[test]
fn summary_only_leaves_every_section_empty() {
// [DOC-MODEL] a summary-only comment has the canonical empty-field shape.
- let doc = DocComment::summary_only("Adds two ints.");
+ let doc = DocComment::new("Adds two ints.", String::new(), DocScope::Outer);
assert_eq!(doc.summary, "Adds two ints.");
assert!(doc.body.is_empty());
assert!(doc.params.is_empty() && doc.returns.is_none());
diff --git a/crates/osprey-ast/src/freevars.rs b/crates/osprey-ast/src/freevars.rs
index 499cf33b..ebf202f9 100644
--- a/crates/osprey-ast/src/freevars.rs
+++ b/crates/osprey-ast/src/freevars.rs
@@ -6,7 +6,7 @@
//! parameters, `let`s in blocks, `match`/`select`/handler pattern bindings)
//! are subtracted; everything else referenced is free.
-use crate::{Expr, InterpolatedPart, MatchArm, Pattern, Stmt};
+use crate::{AstNode, Expr, MatchArm, Pattern, Stmt};
use std::collections::BTreeSet;
/// Collect the free identifiers of `e` into `out` (sorted, deduplicated).
@@ -36,60 +36,8 @@ fn scoped(
fn walk(e: &Expr, bound: &mut Vec, out: &mut BTreeSet) {
match e {
- Expr::Integer(_) | Expr::Float(_) | Expr::Str(_) | Expr::Bool(_) => {}
- Expr::Identifier(n) => note(n, bound, out),
+ Expr::Identifier(name) => note(name, bound, out),
Expr::Path(path) => note(&path.to_string(), bound, out),
- Expr::InterpolatedStr(parts) => {
- for p in parts {
- if let InterpolatedPart::Expr(inner) = p {
- walk(inner, bound, out);
- }
- }
- }
- Expr::List(xs, _) => walk_slice(xs, bound, out, |x| x),
- Expr::Map(entries) => {
- for en in entries {
- walk(&en.key, bound, out);
- walk(&en.value, bound, out);
- }
- }
- Expr::Object(fields) => walk_slice(fields, bound, out, |f| &f.value),
- Expr::Binary { left, right, .. } | Expr::Pipe { left, right } => {
- walk(left, bound, out);
- walk(right, bound, out);
- }
- Expr::Unary { operand, .. } => walk(operand, bound, out),
- e2 => walk_rest(e2, bound, out),
- }
-}
-
-/// Continuation of [`walk`] (kept in thirds so each stays small).
-fn walk_rest(e: &Expr, bound: &mut Vec, out: &mut BTreeSet) {
- match e {
- Expr::Call {
- function,
- arguments,
- named_arguments,
- } => {
- walk(function, bound, out);
- walk_slice(arguments, bound, out, |x| x);
- walk_slice(named_arguments, bound, out, |n| &n.value);
- }
- Expr::MethodCall {
- target,
- arguments,
- named_arguments,
- ..
- } => {
- walk(target, bound, out);
- walk_slice(arguments, bound, out, |x| x);
- walk_slice(named_arguments, bound, out, |n| &n.value);
- }
- Expr::FieldAccess { target, .. } => walk(target, bound, out),
- Expr::Index { target, index } => {
- walk(target, bound, out);
- walk(index, bound, out);
- }
Expr::Lambda {
parameters, body, ..
} => {
@@ -100,52 +48,29 @@ fn walk_rest(e: &Expr, bound: &mut Vec, out: &mut BTreeSet) {
walk(value, bound, out);
walk_arms(arms, bound, out);
}
- Expr::Block { statements, value } => walk_block(statements, value.as_deref(), bound, out),
- // `name { … }` where `name` is a bound local is a record UPDATE that
- // reads `name` (`aggregate::gen_constructor` redirects; the parser
- // cannot tell the forms apart). Noting a real type name is harmless:
- // consumers filter against actual locals (captures via `cg.lookup`,
- // liveness against `let`-bound ledger names).
- Expr::TypeConstructor { name, fields, .. } => {
- note(name, bound, out);
- walk_slice(fields, bound, out, |f| &f.value);
- }
- Expr::Update { record, fields } => {
- note(record, bound, out);
- walk_slice(fields, bound, out, |f| &f.value);
- }
- e2 => walk_fiber(e2, bound, out),
- }
-}
-
-/// Final third of the walker: fiber/effect forms (and the leaf-handled rest).
-fn walk_fiber(e: &Expr, bound: &mut Vec, out: &mut BTreeSet) {
- match e {
- Expr::Spawn(inner) | Expr::Await(inner) | Expr::Recv(inner) | Expr::Yield(Some(inner)) => {
- walk(inner, bound, out);
- }
- Expr::Send { channel, value } => {
- walk(channel, bound, out);
- walk(value, bound, out);
- }
Expr::Select { arms } => walk_arms(arms, bound, out),
- Expr::Perform {
- arguments,
- named_arguments,
- ..
+ Expr::Block { statements, value } => walk_block(statements, value.as_deref(), bound, out),
+ // A constructor spelling can name a local record update. Consumers
+ // filter actual type names against locals; an update's base is a read.
+ Expr::TypeConstructor { name, fields, .. }
+ | Expr::Update {
+ record: name,
+ fields,
} => {
- walk_slice(arguments, bound, out, |x| x);
- walk_slice(named_arguments, bound, out, |n| &n.value);
+ note(name, bound, out);
+ walk_slice(fields, bound, out, |field| &field.value);
}
- Expr::Resume(Some(value)) => walk(value, bound, out),
Expr::Handler { arms, body, .. } => {
for arm in arms {
scoped(bound, arm.params.clone(), out, |b, o| walk(&arm.body, b, o));
}
walk(body, bound, out);
}
- // Every other variant is fully handled by the first two thirds.
- _ => {}
+ _ => AstNode::Expression(e).for_each_child(|child| {
+ if let AstNode::Expression(expression) = child {
+ walk(expression, bound, out);
+ }
+ }),
}
}
diff --git a/crates/osprey-ast/src/lib.rs b/crates/osprey-ast/src/lib.rs
index f086f107..e1c120ac 100644
--- a/crates/osprey-ast/src/lib.rs
+++ b/crates/osprey-ast/src/lib.rs
@@ -26,7 +26,7 @@ pub use generics::{EffectRef, TypeParam, Variance};
pub use multiplicity::{Multiplicity, OperationTable, REPLAYABLE_KEYWORD};
pub use resume::{contains_resume, resumes_on_one_path};
pub use stage::{Stage, STATIC_STAGE_KEYWORD};
-pub use visit::{walk_each, walk_program, AstVisitor};
+pub use visit::{walk_each, walk_program, AstNode, AstVisitor};
/// The one wording for an entry conflict [MODULES-ENTRYPOINT]. Two phases can
/// reach it — the type checker for a plain source, the project assembler for a
@@ -217,6 +217,21 @@ pub struct TypeExpr {
}
impl TypeExpr {
+ /// A module contract supplies a type without adding a written annotation.
+ /// Line zero is reserved for compiler-generated source metadata.
+ #[must_use]
+ pub fn as_contract_annotation(&self) -> Self {
+ let mut ty = self.clone();
+ ty.position = Some(Position { line: 0, column: 0 });
+ ty
+ }
+
+ /// Whether this annotation was supplied by module-signature elaboration.
+ #[must_use]
+ pub fn is_from_contract(&self) -> bool {
+ self.position.is_some_and(|position| position.line == 0)
+ }
+
/// A bare named type like `Int` or `Ptr`.
pub fn named(name: impl Into) -> Self {
TypeExpr {
@@ -765,6 +780,17 @@ pub enum Expr {
/// Named arguments.
named_arguments: Vec,
},
+ /// Explicit declaration-binder arguments on a call's callee.
+ /// Both flavors use this node for [TYPE-GENERICS-APPLY]. Keeping the
+ /// application on the callee preserves ordinary and curried call nodes.
+ TypeApply {
+ /// The named function being instantiated.
+ function: Box,
+ /// Written type arguments, in declaration order.
+ type_args: Vec,
+ /// Source position of the callee, for application diagnostics.
+ position: Option,
+ },
/// `a |> b` pipe.
Pipe {
/// Piped value.
diff --git a/crates/osprey-ast/src/multiplicity.rs b/crates/osprey-ast/src/multiplicity.rs
index 62f83faf..3b9a59bc 100644
--- a/crates/osprey-ast/src/multiplicity.rs
+++ b/crates/osprey-ast/src/multiplicity.rs
@@ -178,17 +178,13 @@ mod tests {
statements: vec![
effect(
"Choice",
- crate::Stage::Dynamic,
+ Stage::Dynamic,
vec![
operation("pick", Some(Multiplicity::Many), false),
operation("seed", None, true),
],
),
- effect(
- "Tile",
- crate::Stage::Static,
- vec![operation("size", None, false)],
- ),
+ effect("Tile", Stage::Static, vec![operation("size", None, false)]),
],
};
let table = OperationTable::collect(&program);
diff --git a/crates/osprey-ast/src/mutate.rs b/crates/osprey-ast/src/mutate.rs
index be73cec9..5d84bfef 100644
--- a/crates/osprey-ast/src/mutate.rs
+++ b/crates/osprey-ast/src/mutate.rs
@@ -45,7 +45,10 @@ pub fn children_mut(expression: &mut Expr, visit: &mut impl FnMut(&mut Expr)) {
visit(left);
visit(right);
}
- Expr::Unary { operand, .. }
+ Expr::TypeApply {
+ function: operand, ..
+ }
+ | Expr::Unary { operand, .. }
| Expr::Spawn(operand)
| Expr::Await(operand)
| Expr::Recv(operand)
diff --git a/crates/osprey-ast/src/resume.rs b/crates/osprey-ast/src/resume.rs
index 4c3cb4ee..3070885c 100644
--- a/crates/osprey-ast/src/resume.rs
+++ b/crates/osprey-ast/src/resume.rs
@@ -9,7 +9,7 @@
//! which is the affine rule multiplicity enforces.
//! Implements [EFFECTS-RESUME], [MULTI-HANDLE-ONCE].
-use crate::{Expr, InterpolatedPart, Stmt};
+use crate::{AstNode, Expr, Stmt};
/// True when `e` contains a `resume` belonging to the ENCLOSING handler arm —
/// a nested handler's body owns its own `resume`s, so they don't count.
@@ -17,66 +17,19 @@ use crate::{Expr, InterpolatedPart, Stmt};
pub fn contains_resume(e: &Expr) -> bool {
match e {
Expr::Resume(_) => true,
- Expr::InterpolatedStr(parts) => parts
- .iter()
- .any(|p| matches!(p, crate::InterpolatedPart::Expr(inner) if contains_resume(inner))),
- Expr::List(xs, _) => xs.iter().any(contains_resume),
- Expr::Map(entries) => entries
- .iter()
- .any(|entry| contains_resume(&entry.key) || contains_resume(&entry.value)),
- Expr::Object(fields)
- | Expr::TypeConstructor { fields, .. }
- | Expr::Update { fields, .. } => fields.iter().any(|f| contains_resume(&f.value)),
- Expr::Binary { left, right, .. } | Expr::Pipe { left, right } => {
- contains_resume(left) || contains_resume(right)
- }
- Expr::Unary { operand, .. } => contains_resume(operand),
- Expr::Call {
- function,
- arguments,
- named_arguments,
- } => {
- contains_resume(function)
- || arguments.iter().any(contains_resume)
- || named_arguments.iter().any(|n| contains_resume(&n.value))
- }
- Expr::MethodCall {
- target,
- arguments,
- named_arguments,
- ..
- } => {
- contains_resume(target)
- || arguments.iter().any(contains_resume)
- || named_arguments.iter().any(|n| contains_resume(&n.value))
- }
- Expr::FieldAccess { target, .. } => contains_resume(target),
- Expr::Index { target, index } => contains_resume(target) || contains_resume(index),
- Expr::Lambda { body, .. } | Expr::Spawn(body) | Expr::Await(body) | Expr::Recv(body) => {
- contains_resume(body)
- }
- Expr::Yield(Some(value)) => contains_resume(value),
- Expr::Send { channel, value } => contains_resume(channel) || contains_resume(value),
- Expr::Match { value, arms } => {
- contains_resume(value) || arms.iter().any(|arm| contains_resume(&arm.body))
- }
- Expr::Block { statements, value } => {
- statements.iter().any(stmt_contains_resume)
- || value.as_deref().is_some_and(contains_resume)
- }
- Expr::Select { arms } => arms.iter().any(|arm| contains_resume(&arm.body)),
- Expr::Perform {
- arguments,
- named_arguments,
- ..
- } => {
- arguments.iter().any(contains_resume)
- || named_arguments.iter().any(|n| contains_resume(&n.value))
- }
- // A nested handler owns its own `resume`; do not mark the outer handler
- // as a resuming region because of it.
+ // Only the handled body belongs to the enclosing arm.
Expr::Handler { body, .. } => contains_resume(body),
- _ => false,
+ _ => {
+ let mut found = false;
+ AstNode::Expression(e).for_each_child(|child| {
+ found = found
+ || match child {
+ AstNode::Statement(statement) => stmt_contains_resume(statement),
+ AstNode::Expression(expression) => contains_resume(expression),
+ };
+ });
+ found
+ }
}
}
@@ -133,74 +86,14 @@ pub fn resumes_on_one_path(body: &Expr) -> u32 {
/// Sum the path length of every child evaluated on the way through `body`.
fn sequential_children(body: &Expr) -> u32 {
- let each = |xs: &[Expr]| xs.iter().map(resumes_on_one_path).sum();
- match body {
- Expr::InterpolatedStr(parts) => parts
- .iter()
- .map(|part| match part {
- InterpolatedPart::Expr(inner) => resumes_on_one_path(inner),
- InterpolatedPart::Text(_) => 0,
- })
- .sum(),
- Expr::List(values, _) => each(values),
- Expr::Map(entries) => entries
- .iter()
- .map(|entry| resumes_on_one_path(&entry.key) + resumes_on_one_path(&entry.value))
- .sum(),
- Expr::Object(fields)
- | Expr::TypeConstructor { fields, .. }
- | Expr::Update { fields, .. } => fields.iter().map(|f| resumes_on_one_path(&f.value)).sum(),
- Expr::Binary { left, right, .. } | Expr::Pipe { left, right } => {
- resumes_on_one_path(left) + resumes_on_one_path(right)
- }
- Expr::Unary { operand, .. } => resumes_on_one_path(operand),
- Expr::Call {
- function,
- arguments,
- named_arguments,
- } => {
- resumes_on_one_path(function)
- + each(arguments)
- + named_arguments
- .iter()
- .map(|n| resumes_on_one_path(&n.value))
- .sum::()
- }
- Expr::MethodCall {
- target,
- arguments,
- named_arguments,
- ..
- } => {
- resumes_on_one_path(target)
- + each(arguments)
- + named_arguments
- .iter()
- .map(|n| resumes_on_one_path(&n.value))
- .sum::()
- }
- Expr::FieldAccess { target, .. } => resumes_on_one_path(target),
- Expr::Index { target, index } => resumes_on_one_path(target) + resumes_on_one_path(index),
- Expr::Spawn(inner) | Expr::Await(inner) | Expr::Recv(inner) => resumes_on_one_path(inner),
- Expr::Yield(value) => value.as_deref().map_or(0, resumes_on_one_path),
- Expr::Send { channel, value } => resumes_on_one_path(channel) + resumes_on_one_path(value),
- Expr::Block { statements, value } => {
- statements.iter().map(statement_resumes).sum::()
- + value.as_deref().map_or(0, resumes_on_one_path)
- }
- Expr::Perform {
- arguments,
- named_arguments,
- ..
- } => {
- each(arguments)
- + named_arguments
- .iter()
- .map(|n| resumes_on_one_path(&n.value))
- .sum::()
- }
- _ => 0,
- }
+ let mut total = 0;
+ AstNode::Expression(body).for_each_child(|child| {
+ total += match child {
+ AstNode::Statement(statement) => statement_resumes(statement),
+ AstNode::Expression(expression) => resumes_on_one_path(expression),
+ };
+ });
+ total
}
fn statement_resumes(stmt: &Stmt) -> u32 {
diff --git a/crates/osprey-ast/src/resume_tests.rs b/crates/osprey-ast/src/resume_tests.rs
index 216c9a72..2b59237a 100644
--- a/crates/osprey-ast/src/resume_tests.rs
+++ b/crates/osprey-ast/src/resume_tests.rs
@@ -33,18 +33,18 @@ fn field(value: Expr) -> crate::FieldAssignment {
value,
}
}
-fn assert_all_contain(cases: &[Expr]) {
- for e in cases {
- assert!(contains_resume(e), "resume not found in {e:?}");
- }
-}
-
-#[test]
-fn walks_literal_and_data_container_forms() {
- assert_all_contain(&[
- Expr::InterpolatedStr(vec![crate::InterpolatedPart::Expr(r())]),
+/// Every expression form that holds a sub-expression in a **container**
+/// position, each built around exactly one `resume()`. The containment walk and
+/// the one-path count must both cross all of them, so the list is stated once
+/// here instead of once per test, where the two copies could drift apart.
+fn container_forms() -> Vec {
+ vec![
+ Expr::InterpolatedStr(vec![
+ InterpolatedPart::Text("t".into()),
+ InterpolatedPart::Expr(r()),
+ ]),
Expr::List(vec![r()], None),
- Expr::Map(vec![crate::MapEntry {
+ Expr::Map(vec![MapEntry {
key: r(),
value: Expr::Integer(0),
}]),
@@ -71,16 +71,23 @@ fn walks_literal_and_data_container_forms() {
op: "-".into(),
operand: b(r()),
},
- ]);
+ ]
}
-#[test]
-fn walks_call_control_and_concurrency_forms() {
- assert_all_contain(&[
+/// The call, field and concurrency forms — still one sequential path each, so
+/// they too are crossed exactly once. Positional and named argument lists are
+/// both listed, because they are separate positions in the walk.
+fn call_forms() -> Vec {
+ vec![
+ Expr::Call {
+ function: b(Expr::Identifier("f".into())),
+ arguments: vec![r()],
+ named_arguments: Vec::new(),
+ },
Expr::Call {
function: b(Expr::Identifier("f".into())),
arguments: Vec::new(),
- named_arguments: vec![crate::NamedArgument {
+ named_arguments: vec![NamedArgument {
name: "a".into(),
value: r(),
}],
@@ -99,12 +106,6 @@ fn walks_call_control_and_concurrency_forms() {
target: b(Expr::Identifier("xs".into())),
index: b(r()),
},
- Expr::Lambda {
- parameters: Vec::new(),
- return_type: None,
- body: b(r()),
- position: None,
- },
Expr::Spawn(b(r())),
Expr::Await(b(r())),
Expr::Recv(b(r())),
@@ -113,16 +114,6 @@ fn walks_call_control_and_concurrency_forms() {
channel: b(Expr::Integer(0)),
value: b(r()),
},
- Expr::Match {
- value: b(r()),
- arms: Vec::new(),
- },
- Expr::Select {
- arms: vec![crate::MatchArm {
- pattern: crate::Pattern::Wildcard,
- body: r(),
- }],
- },
Expr::Perform {
effect: "E".into(),
operation: "o".into(),
@@ -130,7 +121,45 @@ fn walks_call_control_and_concurrency_forms() {
named_arguments: Vec::new(),
position: None,
},
- ]);
+ ]
+}
+
+/// The forms whose sub-expression is NOT on one sequential path: a lambda body
+/// runs later, and `match`/`select` arms are alternatives. The walk still finds
+/// a `resume` inside them — the one-path count deliberately does not cross them.
+fn branching_forms() -> Vec {
+ vec![
+ Expr::Lambda {
+ parameters: Vec::new(),
+ return_type: None,
+ body: b(r()),
+ position: None,
+ },
+ Expr::Match {
+ value: b(r()),
+ arms: Vec::new(),
+ },
+ Expr::Select {
+ arms: vec![arm(r())],
+ },
+ ]
+}
+
+fn assert_all_contain(cases: &[Expr]) {
+ for e in cases {
+ assert!(contains_resume(e), "resume not found in {e:?}");
+ }
+}
+
+#[test]
+fn walks_literal_and_data_container_forms() {
+ assert_all_contain(&container_forms());
+}
+
+#[test]
+fn walks_call_control_and_concurrency_forms() {
+ assert_all_contain(&call_forms());
+ assert_all_contain(&branching_forms());
}
#[test]
@@ -139,7 +168,7 @@ fn negatives_and_statement_walks() {
assert!(!contains_resume(&Expr::Integer(1)));
assert!(!contains_resume(&Expr::Yield(None)));
let import_only = Expr::Block {
- statements: vec![crate::Stmt::Import(crate::ImportDecl {
+ statements: vec![Stmt::Import(crate::ImportDecl {
target: crate::ImportTarget {
namespace: crate::NamespaceName::Identifier("m".into()),
path: crate::SymbolPath::default(),
@@ -153,7 +182,7 @@ fn negatives_and_statement_walks() {
assert!(!contains_resume(&import_only));
// Assignment statements inside blocks are walked.
let assign = Expr::Block {
- statements: vec![crate::Stmt::Assignment {
+ statements: vec![Stmt::Assignment {
name: "x".into(),
value: r(),
position: None,
@@ -180,7 +209,7 @@ fn finds_resume_through_blocks_but_not_nested_handlers() {
let nested = Expr::Handler {
stage: crate::Stage::Dynamic,
effect: "E".into(),
- arms: vec![crate::HandlerArm {
+ arms: vec![HandlerArm {
operation: "op".into(),
params: Vec::new(),
body: Expr::Resume(None),
@@ -250,87 +279,10 @@ fn select_branches_and_lambdas_and_nested_handlers() {
#[test]
fn every_sequential_position_is_crossed() {
- let cases = [
- Expr::InterpolatedStr(vec![
- InterpolatedPart::Text("t".into()),
- InterpolatedPart::Expr(r()),
- ]),
- Expr::List(vec![r()], None),
- Expr::Map(vec![MapEntry {
- key: r(),
- value: Expr::Integer(0),
- }]),
- Expr::Object(vec![field(r())]),
- Expr::TypeConstructor {
- name: "C".into(),
- type_args: Vec::new(),
- fields: vec![field(r())],
- },
- Expr::Update {
- record: "r".into(),
- fields: vec![field(r())],
- },
- Expr::Binary {
- op: "+".into(),
- left: b(Expr::Integer(1)),
- right: b(r()),
- },
- Expr::Pipe {
- left: b(r()),
- right: b(Expr::Identifier("f".into())),
- },
- Expr::Unary {
- op: "-".into(),
- operand: b(r()),
- },
- Expr::Call {
- function: b(Expr::Identifier("f".into())),
- arguments: vec![r()],
- named_arguments: Vec::new(),
- },
- Expr::MethodCall {
- target: b(r()),
- method: "m".into(),
- arguments: Vec::new(),
- named_arguments: Vec::new(),
- },
- Expr::FieldAccess {
- target: b(r()),
- field: "x".into(),
- },
- Expr::Index {
- target: b(Expr::Identifier("xs".into())),
- index: b(r()),
- },
- Expr::Spawn(b(r())),
- Expr::Await(b(r())),
- Expr::Recv(b(r())),
- Expr::Yield(Some(b(r()))),
- Expr::Send {
- channel: b(Expr::Integer(0)),
- value: b(r()),
- },
- Expr::Perform {
- effect: "E".into(),
- operation: "op".into(),
- arguments: vec![r()],
- named_arguments: Vec::new(),
- position: None,
- },
- ];
- for case in &cases {
+ for case in container_forms().iter().chain(&call_forms()) {
assert_eq!(resumes_on_one_path(case), 1, "not crossed: {case:?}");
}
- // Named arguments are crossed too, and a value-less `yield` crosses nothing.
- let named = Expr::Call {
- function: b(Expr::Identifier("f".into())),
- arguments: Vec::new(),
- named_arguments: vec![NamedArgument {
- name: "a".into(),
- value: r(),
- }],
- };
- assert_eq!(resumes_on_one_path(&named), 1);
+ // A value-less `yield` and a bare identifier cross nothing.
assert_eq!(resumes_on_one_path(&Expr::Yield(None)), 0);
assert_eq!(resumes_on_one_path(&Expr::Identifier("x".into())), 0);
}
diff --git a/crates/osprey-ast/src/stage.rs b/crates/osprey-ast/src/stage.rs
index a3ed12b9..4bf1b7d5 100644
--- a/crates/osprey-ast/src/stage.rs
+++ b/crates/osprey-ast/src/stage.rs
@@ -297,7 +297,7 @@ fn instantiation_errors(
if declared.stage == Stage::Dynamic {
return vec![StageError::new(
format!(
- "`{site} {effect}` names an instantiation of dynamic effect `{base}`; a dynamic handler is keyed by effect name at runtime, so instantiations share one key and cannot be told apart (docs/plans/0024-staged-effects.md). Declare `static effect {base}`, or write `{site} {base}` and let inference instantiate it"
+ "`{site} {effect}` names an instantiation of dynamic effect `{base}`; a written instantiation is the identity of a `static effect`, while a dynamic effect takes its instantiation from inference (docs/plans/0024-staged-effects.md). Declare `static effect {base}`, or write `{site} {base}` and let inference instantiate it"
),
position,
)];
diff --git a/crates/osprey-ast/src/visit.rs b/crates/osprey-ast/src/visit.rs
index 91f69f74..c22889b4 100644
--- a/crates/osprey-ast/src/visit.rs
+++ b/crates/osprey-ast/src/visit.rs
@@ -18,11 +18,26 @@ pub trait AstVisitor {
fn expression(&mut self, _expression: &Expr) {}
}
-enum Node<'a> {
+/// A borrowed syntax node whose immediate children can be visited in source order.
+#[derive(Debug, Clone, Copy)]
+pub enum AstNode<'a> {
+ /// A declaration or executable statement.
Statement(&'a Stmt),
+ /// An expression, including any statements in a block.
Expression(&'a Expr),
}
+impl AstNode<'_> {
+ /// Visit immediate children only. Callers retain control of recursion,
+ /// lexical scopes, and branch-specific combination rules.
+ pub fn for_each_child(self, mut visit: impl FnMut(Self)) {
+ match self {
+ Self::Statement(statement) => statement_children(statement, &mut visit),
+ Self::Expression(expression) => expression_children(expression, &mut visit),
+ }
+ }
+}
+
/// Walk every statement and expression in source order without recursive
/// visitor boilerplate. Implements the shared traversal required by
/// [LSP-HOVER-EFFECT-OPERATIONS] and [LSP-IMPLEMENTATIONS-EFFECT-HANDLERS].
@@ -31,134 +46,134 @@ pub fn walk_program(program: &Program, visitor: &mut impl AstVisitor) {
.statements
.iter()
.rev()
- .map(Node::Statement)
+ .map(AstNode::Statement)
.collect();
while let Some(node) = pending.pop() {
match node {
- Node::Statement(statement) => {
- visitor.statement(statement);
- push_statement_children(statement, &mut pending);
- }
- Node::Expression(expression) => {
- visitor.expression(expression);
- push_expression_children(expression, &mut pending);
- }
+ AstNode::Statement(statement) => visitor.statement(statement),
+ AstNode::Expression(expression) => visitor.expression(expression),
+ }
+ let start = pending.len();
+ node.for_each_child(|child| pending.push(child));
+ if let Some(children) = pending.get_mut(start..) {
+ children.reverse();
}
}
}
-fn push_statement_children<'a>(statement: &'a Stmt, pending: &mut Vec>) {
+fn statement_children<'a>(statement: &'a Stmt, visit: &mut impl FnMut(AstNode<'a>)) {
match statement {
Stmt::Namespace { body, .. } => {
- pending.extend(body.iter().rev().map(Node::Statement));
+ for statement in body {
+ visit(AstNode::Statement(statement));
+ }
+ }
+ Stmt::Module { body, .. } => {
+ for item in body {
+ visit(AstNode::Statement(&item.declaration));
+ }
}
- Stmt::Module { body, .. } => pending.extend(
- body.iter()
- .rev()
- .map(|item| Node::Statement(item.declaration.as_ref())),
- ),
Stmt::Let { value, .. }
| Stmt::Assignment { value, .. }
| Stmt::Expr { value, .. }
- | Stmt::Function { body: value, .. } => pending.push(Node::Expression(value)),
- Stmt::Type { variants, .. } => push_constraints(variants, pending),
- Stmt::Import(_) | Stmt::Extern { .. } | Stmt::Effect { .. } | Stmt::Signature { .. } => {}
- }
-}
-
-fn push_constraints<'a>(variants: &'a [crate::TypeVariant], pending: &mut Vec>) {
- for variant in variants.iter().rev() {
- for field in variant.fields.iter().rev() {
- if let Some(constraint) = &field.constraint {
- pending.push(Node::Expression(constraint));
+ | Stmt::Function { body: value, .. } => visit(AstNode::Expression(value)),
+ Stmt::Type { variants, .. } => {
+ for field in variants.iter().flat_map(|variant| &variant.fields) {
+ if let Some(constraint) = &field.constraint {
+ visit(AstNode::Expression(constraint));
+ }
}
}
+ Stmt::Import(_) | Stmt::Extern { .. } | Stmt::Effect { .. } | Stmt::Signature { .. } => {}
}
}
-fn push_expression_children<'a>(expression: &'a Expr, pending: &mut Vec>) {
+fn expression_children<'a>(expression: &'a Expr, visit: &mut impl FnMut(AstNode<'a>)) {
match expression {
Expr::InterpolatedStr(parts) => {
- for part in parts.iter().rev() {
+ for part in parts {
if let InterpolatedPart::Expr(value) = part {
- pending.push(Node::Expression(value));
+ visit(AstNode::Expression(value));
}
}
}
- Expr::List(values, _) => push_each(values, pending, |value| value),
+ Expr::List(values, _) => visit_each(values, visit, |value| value),
Expr::Map(entries) => {
- for entry in entries.iter().rev() {
- pending.push(Node::Expression(&entry.value));
- pending.push(Node::Expression(&entry.key));
+ for entry in entries {
+ visit(AstNode::Expression(&entry.key));
+ visit(AstNode::Expression(&entry.value));
}
}
Expr::Object(fields)
| Expr::TypeConstructor { fields, .. }
- | Expr::Update { fields, .. } => push_each(fields, pending, |field| &field.value),
+ | Expr::Update { fields, .. } => visit_each(fields, visit, |field| &field.value),
Expr::Binary { left, right, .. } | Expr::Pipe { left, right } => {
- pending.push(Node::Expression(right));
- pending.push(Node::Expression(left));
+ visit(AstNode::Expression(left));
+ visit(AstNode::Expression(right));
+ }
+ Expr::TypeApply {
+ function: operand, ..
}
- Expr::Unary { operand, .. }
+ | Expr::Unary { operand, .. }
| Expr::Spawn(operand)
| Expr::Await(operand)
- | Expr::Recv(operand) => pending.push(Node::Expression(operand)),
+ | Expr::Recv(operand)
+ | Expr::FieldAccess {
+ target: operand, ..
+ }
+ | Expr::Lambda { body: operand, .. } => visit(AstNode::Expression(operand)),
Expr::Call {
- function,
+ function: target,
arguments,
named_arguments,
- } => {
- push_each(named_arguments, pending, |argument| &argument.value);
- push_each(arguments, pending, |argument| argument);
- pending.push(Node::Expression(function));
}
- Expr::MethodCall {
+ | Expr::MethodCall {
target,
arguments,
named_arguments,
..
} => {
- push_each(named_arguments, pending, |argument| &argument.value);
- push_each(arguments, pending, |argument| argument);
- pending.push(Node::Expression(target));
+ visit(AstNode::Expression(target));
+ visit_each(arguments, visit, |argument| argument);
+ visit_each(named_arguments, visit, |argument| &argument.value);
}
- Expr::FieldAccess { target, .. } => pending.push(Node::Expression(target)),
Expr::Index { target, index } => {
- pending.push(Node::Expression(index));
- pending.push(Node::Expression(target));
+ visit(AstNode::Expression(target));
+ visit(AstNode::Expression(index));
}
- Expr::Lambda { body, .. } => pending.push(Node::Expression(body)),
Expr::Match { value, arms } => {
- push_each(arms, pending, |arm| &arm.body);
- pending.push(Node::Expression(value));
+ visit(AstNode::Expression(value));
+ visit_each(arms, visit, |arm| &arm.body);
}
Expr::Block { statements, value } => {
+ for statement in statements {
+ visit(AstNode::Statement(statement));
+ }
if let Some(value) = value {
- pending.push(Node::Expression(value));
+ visit(AstNode::Expression(value));
}
- pending.extend(statements.iter().rev().map(Node::Statement));
}
Expr::Yield(value) | Expr::Resume(value) => {
if let Some(value) = value {
- pending.push(Node::Expression(value));
+ visit(AstNode::Expression(value));
}
}
Expr::Send { channel, value } => {
- pending.push(Node::Expression(value));
- pending.push(Node::Expression(channel));
+ visit(AstNode::Expression(channel));
+ visit(AstNode::Expression(value));
}
- Expr::Select { arms } => push_each(arms, pending, |arm| &arm.body),
+ Expr::Select { arms } => visit_each(arms, visit, |arm| &arm.body),
Expr::Perform {
arguments,
named_arguments,
..
} => {
- push_each(named_arguments, pending, |argument| &argument.value);
- push_each(arguments, pending, |argument| argument);
+ visit_each(arguments, visit, |argument| argument);
+ visit_each(named_arguments, visit, |argument| &argument.value);
}
Expr::Handler { arms, body, .. } => {
- pending.push(Node::Expression(body));
- push_each(arms, pending, |arm| &arm.body);
+ visit_each(arms, visit, |arm| &arm.body);
+ visit(AstNode::Expression(body));
}
Expr::Integer(_)
| Expr::Float(_)
@@ -169,17 +184,14 @@ fn push_expression_children<'a>(expression: &'a Expr, pending: &mut Vec
}
}
-fn push_each<'a, T>(
+fn visit_each<'a, T>(
items: &'a [T],
- pending: &mut Vec>,
+ visit: &mut impl FnMut(AstNode<'a>),
expression: impl Fn(&'a T) -> &'a Expr,
) {
- pending.extend(
- items
- .iter()
- .rev()
- .map(|item| Node::Expression(expression(item))),
- );
+ for item in items {
+ visit(AstNode::Expression(expression(item)));
+ }
}
/// Recurse into every element of `items`, projecting each to its
diff --git a/crates/osprey-cli/src/android.rs b/crates/osprey-cli/src/android.rs
index 4263e985..eb2b95dd 100644
--- a/crates/osprey-cli/src/android.rs
+++ b/crates/osprey-cli/src/android.rs
@@ -43,18 +43,11 @@ impl Target {
/// Unsupported options fail even when only checking a program. [ANDROID-TARGET-OPTIONS]
pub(crate) fn validate(cli: &Cli) -> Result<(), ExitCode> {
- if let Some(code) = crate::reject_debug_cross_target(cli) {
- return Err(code);
- }
- if cli.memory != "default" {
- return Err(fail(
- "Android supports --memory=default; other runtime archives are not available",
- ));
- }
- if cli.mode == "--run" {
- return Err(fail("Android produces an app-logic library; use --compile and call it from an Android host (see examples/mobile/android/)"));
- }
- Ok(())
+ crate::reject_cross_target_options(
+ cli,
+ "Android",
+ Some("an Android host (see examples/mobile/android/)"),
+ )
}
pub(crate) fn source(
@@ -73,11 +66,7 @@ pub(crate) fn build(
out: &Path,
target: Target,
) -> Result<(), ExitCode> {
- if out.extension().and_then(|e| e.to_str()) != Some("a") {
- return Err(fail(
- "Android output must end in .a; a matching .h is generated beside it",
- ));
- }
+ crate::toolchain::validate_archive_output(out, "Android").map_err(|e| fail(&e))?;
let (ir, header) = source(program, path, target).map_err(|e| fail(&e))?;
let bin = ndk_bin().map_err(|e| fail(&e))?;
let runtime = find_runtime_lib(target.runtime()).ok_or_else(|| {
diff --git a/crates/osprey-cli/src/docs.rs b/crates/osprey-cli/src/docs.rs
index 0af80b43..66f07800 100644
--- a/crates/osprey-cli/src/docs.rs
+++ b/crates/osprey-cli/src/docs.rs
@@ -16,7 +16,7 @@ use std::path::{Path, PathBuf};
use std::process::ExitCode;
/// Entry point for the `--docs` mode. Reads `--docs-dir ` from `args`.
-pub fn run(args: &[String]) -> ExitCode {
+pub(crate) fn run(args: &[String]) -> ExitCode {
let dir = if let Some(dir) = docs_dir(args) {
PathBuf::from(dir)
} else {
diff --git a/crates/osprey-cli/src/fmt.rs b/crates/osprey-cli/src/fmt.rs
index b4aae630..eeb52568 100644
--- a/crates/osprey-cli/src/fmt.rs
+++ b/crates/osprey-cli/src/fmt.rs
@@ -35,7 +35,7 @@ struct Tally {
}
/// Entry point for `osprey fmt`; `args` excludes the `fmt` subcommand word.
-pub fn run(args: &[String]) -> ExitCode {
+pub(crate) fn run(args: &[String]) -> ExitCode {
let parsed = match parse(args) {
Ok(parsed) => parsed,
Err(message) => {
diff --git a/crates/osprey-cli/src/ios.rs b/crates/osprey-cli/src/ios.rs
index 415fef4f..be3c2370 100644
--- a/crates/osprey-cli/src/ios.rs
+++ b/crates/osprey-cli/src/ios.rs
@@ -60,18 +60,7 @@ impl Target {
/// Refuse native-only settings before invoking the cross compiler.
/// Implements [IOS-TARGET-OPTIONS].
pub(crate) fn validate(cli: &Cli) -> Result<(), ExitCode> {
- if let Some(code) = crate::reject_debug_cross_target(cli) {
- return Err(code);
- }
- if cli.memory != "default" {
- return Err(fail(
- "iOS supports --memory=default; other runtime archives are not available",
- ));
- }
- if cli.mode == "--run" {
- return Err(fail("iOS produces an app-logic library; use --compile and call it from a Swift host (see examples/ios/)"));
- }
- Ok(())
+ crate::reject_cross_target_options(cli, "iOS", Some("a Swift host (see examples/ios/)"))
}
/// Emit the app's C ABI and LLVM implementation before any toolchain work.
@@ -116,10 +105,7 @@ pub(crate) fn build(
}
fn validate_output(out: &Path) -> Result<(), String> {
- if out.extension().and_then(|e| e.to_str()) != Some("a") {
- return Err("iOS output must end in .a; a matching .h is generated beside it".to_string());
- }
- Ok(())
+ crate::toolchain::validate_archive_output(out, "iOS")
}
fn sdk_path(target: Target) -> Result {
diff --git a/crates/osprey-cli/src/ios_abi_tests.rs b/crates/osprey-cli/src/ios_abi_tests.rs
index c314fdf2..e1e8cb05 100644
--- a/crates/osprey-cli/src/ios_abi_tests.rs
+++ b/crates/osprey-cli/src/ios_abi_tests.rs
@@ -1,4 +1,5 @@
use super::*;
+use crate::testkit::shows;
use std::path::{Path, PathBuf};
const SOURCE: &str = "extern fn host_log(message: string) -> int\n\
@@ -67,13 +68,23 @@ fn thunks_rename_the_entry_and_forward_with_the_c_bool_convention() {
let out = with_host_abi(&ir, &abi).expect("thunked");
assert!(out.contains("define i32 @osprey_main() "), "entry renamed");
assert!(!out.contains("@main("), "no `main` symbol survives");
- assert!(out.contains("define zeroext i1 @osprey_flag(i1 zeroext %p0) {"));
- assert!(out.contains(" %r = call i1 @flag(i1 %p0)\n ret i1 %r"));
+ shows(
+ &out,
+ &[
+ "define zeroext i1 @osprey_flag(i1 zeroext %p0) {",
+ " %r = call i1 @flag(i1 %p0)\n ret i1 %r",
+ ],
+ );
assert!(out
.contains("define void @osprey_shout(i8* %p0) {\n call i64 @shout(i8* %p0)\n ret void"));
- assert!(out.contains("define i8* @osprey_greet(i8* %p0) {"));
- assert!(out.contains("define double @osprey_scaled(i64 %p0) {"));
- assert!(out.contains("define i64 @osprey_total(i64 %p0, i64 %p1) {"));
+ shows(
+ &out,
+ &[
+ "define i8* @osprey_greet(i8* %p0) {",
+ "define double @osprey_scaled(i64 %p0) {",
+ "define i64 @osprey_total(i64 %p0, i64 %p1) {",
+ ],
+ );
assert!(with_host_abi("; no entry here", &abi).is_err());
}
@@ -277,8 +288,10 @@ fn unsupported_extern_signatures_report_the_c_boundary_restriction() {
fn renaming_imports_preserves_strings_and_similarly_prefixed_symbols() {
let (abi, ir) = abi_of("extern fn host_flag(b: bool) -> bool\nfn host_flag_more(b) = host_flag(b)\nfn text() = \"@host_flag( @main(\"\n");
let out = with_host_abi(&ir, &abi).expect("adapted");
- assert!(out.contains("c\"@host_flag( @main(\\00\""), "{out}");
- assert!(out.contains("define i1 @host_flag_more("), "{out}");
+ shows(
+ &out,
+ &["c\"@host_flag( @main(\\00\"", "define i1 @host_flag_more("],
+ );
}
#[test]
diff --git a/crates/osprey-cli/src/main.rs b/crates/osprey-cli/src/main.rs
index 31f09be7..2ca136a5 100644
--- a/crates/osprey-cli/src/main.rs
+++ b/crates/osprey-cli/src/main.rs
@@ -29,7 +29,11 @@ mod target_capabilities;
mod test_cmd;
mod test_coverage;
mod test_skips;
+#[cfg(test)]
+#[path = "../../testkit.rs"]
+mod testkit;
mod toolchain;
+mod warnings;
mod wasm;
use osprey_syntax::Flavor;
@@ -381,7 +385,7 @@ pub(crate) fn load_input(cli: &Cli) -> Result {
eprintln!("error: --flavor applies to single files; projects select flavor per source");
return Err(ExitCode::from(2));
}
- return project::CompilationInput::load_project(path).map_err(|errors| {
+ return CompilationInput::load_project(path).map_err(|errors| {
print_project_errors(&errors, path);
ExitCode::FAILURE
});
@@ -464,11 +468,16 @@ fn dispatch(cli: &Cli, input: &CompilationInput) -> ExitCode {
/// Type-check `program`, print every error in `file:line:col: message` form,
/// and return how many there were. The shared gate for every compiling mode.
+///
+/// Warnings print alongside the errors and are deliberately not counted: a
+/// redundant annotation is a defect to delete, never a reason to fail a build
+/// ([TYPE-ANNOTATION-REDUNDANT]).
pub(crate) fn report_type_errors(input: &CompilationInput) -> usize {
let errors = osprey_types::check_program(input.program());
for e in &errors {
eprintln!("{}", input.diagnostic(e.position, &e.message));
}
+ warnings::report(input, &osprey_types::redundant_annotations(input.program()));
errors.len()
}
@@ -494,34 +503,37 @@ fn target_error(cli: &Cli, input: &CompilationInput) -> Option {
return Some(ExitCode::FAILURE);
}
if cli.target == "wasm32" {
- if let Some(code) = reject_debug_cross_target(cli) {
+ if let Err(code) = reject_cross_target_options(cli, "wasm32", None) {
return Some(code);
}
- if cli.memory != "default" {
- return Some(toolchain::fail(
- "wasm32 supports --memory=default; other runtime archives are not available",
- ));
- }
}
if let Some(target) = android::Target::parse(&cli.target) {
- if let Err(code) = android::validate(cli) {
- return Some(code);
- }
- if cli.mode == "--check" {
- return android::source(input.program(), input.debug_path(), target)
- .err()
- .map(|error| toolchain::fail(&error));
- }
+ return app_target_error(&cli.mode, android::validate(cli), || {
+ android::source(input.program(), input.debug_path(), target)
+ });
}
if let Some(target) = ios::Target::parse(&cli.target) {
- if let Err(code) = ios::validate(cli) {
- return Some(code);
- }
- if cli.mode == "--check" {
- return ios::source(input.program(), input.debug_path(), target)
- .err()
- .map(|error| toolchain::fail(&error));
- }
+ return app_target_error(&cli.mode, ios::validate(cli), || {
+ ios::source(input.program(), input.debug_path(), target)
+ });
+ }
+ None
+}
+
+/// The app-library targets (iOS, Android) share one order: reject the
+/// unsupported options, then — for `--check` alone — generate the C ABI and
+/// report its failure as a diagnostic. `source` stays lazy so no other mode
+/// pays for ABI generation, and so option errors always win the race.
+fn app_target_error(
+ mode: &str,
+ validation: Result<(), ExitCode>,
+ source: impl FnOnce() -> Result<(String, String), String>,
+) -> Option {
+ if let Err(code) = validation {
+ return Some(code);
+ }
+ if mode == "--check" {
+ return source().err().map(|error| toolchain::fail(&error));
}
None
}
@@ -551,17 +563,43 @@ fn reject_debug_cross_target(cli: &Cli) -> Option {
None
}
+/// Every cross target refuses the native-only build flags and the non-default
+/// runtime archives. A target that produces a LIBRARY rather than a runnable
+/// image also refuses `--run`, and names the host that calls it in `host_hint`;
+/// `None` marks a target with a `--run` form of its own.
+/// Implements [IOS-TARGET-OPTIONS] and [ANDROID-TARGET-OPTIONS].
+fn reject_cross_target_options(
+ cli: &Cli,
+ platform: &str,
+ host_hint: Option<&str>,
+) -> Result<(), ExitCode> {
+ if let Some(code) = reject_debug_cross_target(cli) {
+ return Err(code);
+ }
+ if cli.memory != "default" {
+ return Err(toolchain::fail(&format!(
+ "{platform} supports --memory=default; other runtime archives are not available"
+ )));
+ }
+ match host_hint {
+ Some(hint) if cli.mode == "--run" => Err(toolchain::fail(&format!(
+ "{platform} produces an app-logic library; use --compile and call it from {hint}"
+ ))),
+ _ => Ok(()),
+ }
+}
+
/// The native build kind this invocation asked for (`--debug` and `--profile`
/// are mutually exclusive; `parse_args` enforces that).
fn build_kind(cli: &Cli) -> osprey_debug::BuildKind {
if cli.debug {
- osprey_debug::BuildKind::Debug
+ osprey_debug::DebugBuild::ON.kind()
} else if cli.profile {
osprey_debug::BuildKind::Profile
} else if std::env::var_os(TEST_COVERAGE_BUILD_ENV).is_some() {
osprey_debug::BuildKind::Coverage
} else {
- osprey_debug::BuildKind::Release
+ osprey_debug::DebugBuild::OFF.kind()
}
}
diff --git a/crates/osprey-cli/src/project.rs b/crates/osprey-cli/src/project.rs
index b101f0d1..0bed56c6 100644
--- a/crates/osprey-cli/src/project.rs
+++ b/crates/osprey-cli/src/project.rs
@@ -128,24 +128,24 @@ impl CompilationInput {
&self.debug_path
}
+ /// Resolve a flattened checker position to the physical file it was
+ /// written in, with that file's own line number.
+ pub(crate) fn location(&self, position: Position) -> (String, u32, u32) {
+ if let CompilationUnit::Project(project) = &self.unit {
+ if let Some((source, line)) = project.source_at_line(position.line) {
+ return (source.path.display().to_string(), line, position.column);
+ }
+ }
+ (self.display_path.clone(), position.line, position.column)
+ }
+
/// Format a flattened checker location using its physical source file.
pub(crate) fn diagnostic(&self, position: Option, message: &str) -> String {
let Some(position) = position else {
return format!("{}: {message}", self.display_path);
};
- if let CompilationUnit::Project(project) = &self.unit {
- if let Some((source, line)) = project.source_at_line(position.line) {
- return format!(
- "{}:{line}:{}: {message}",
- source.path.display(),
- position.column
- );
- }
- }
- format!(
- "{}:{}:{}: {message}",
- self.display_path, position.line, position.column
- )
+ let (path, line, column) = self.location(position);
+ format!("{path}:{line}:{column}: {message}")
}
/// Render symbols with source-level qualified names where assembly mangled them.
diff --git a/crates/osprey-cli/src/toolchain.rs b/crates/osprey-cli/src/toolchain.rs
index 6730cee1..cfbb82c5 100644
--- a/crates/osprey-cli/src/toolchain.rs
+++ b/crates/osprey-cli/src/toolchain.rs
@@ -26,6 +26,17 @@ pub(crate) fn fail(msg: &str) -> ExitCode {
ExitCode::FAILURE
}
+/// An app-library target publishes a static archive plus a matching C header,
+/// so `-o` must name the archive. `platform` opens the diagnostic.
+pub(crate) fn validate_archive_output(out: &Path, platform: &str) -> Result<(), String> {
+ if out.extension().and_then(|e| e.to_str()) != Some("a") {
+ return Err(format!(
+ "{platform} output must end in .a; a matching .h is generated beside it"
+ ));
+ }
+ Ok(())
+}
+
pub(crate) fn write(path: &Path, contents: &str) -> Result<(), ExitCode> {
std::fs::write(path, contents)
.map_err(|e| fail(&format!("cannot write {}: {e}", path.display())))
diff --git a/crates/osprey-cli/src/warnings.rs b/crates/osprey-cli/src/warnings.rs
new file mode 100644
index 00000000..b95b4d33
--- /dev/null
+++ b/crates/osprey-cli/src/warnings.rs
@@ -0,0 +1,175 @@
+//! Terminal rendering for compiler warnings.
+//!
+//! A warning is advice, and a hundred of them are only useful if a reader can
+//! see the shape of the advice at a glance. Warnings are therefore grouped by
+//! the file they were written in, listed under an aligned `line:column`
+//! gutter, and closed with the count and the rules that raised them, so the
+//! summary answers "how much of this is there, and what turned it on" without
+//! scrolling back.
+//!
+//! Rendering is a pure function over the diagnostics so the exact text is
+//! testable; printing is the only side effect.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use osprey_types::TypeWarning;
+
+use crate::project::CompilationInput;
+
+/// One file's warnings: the `line:column` gutter and the message, in order.
+type Listing = Vec<(String, String)>;
+
+/// Print `warnings` to stderr. A clean build prints nothing.
+pub(crate) fn report(input: &CompilationInput, warnings: &[TypeWarning]) {
+ if let Some(text) = render(input, warnings) {
+ eprintln!("{text}");
+ }
+}
+
+/// The whole warning block, or `None` when there is nothing to say.
+pub(crate) fn render(input: &CompilationInput, warnings: &[TypeWarning]) -> Option {
+ if warnings.is_empty() {
+ return None;
+ }
+ let blocks: Vec = group(input, warnings)
+ .into_iter()
+ .map(|(file, listing)| block(&file, &listing))
+ .collect();
+ Some(format!("{}\n{}", blocks.join("\n"), summary(warnings)))
+}
+
+/// One file's heading and its aligned listing.
+fn block(file: &str, listing: &Listing) -> String {
+ let width = listing
+ .iter()
+ .map(|(gutter, _)| gutter.len())
+ .max()
+ .unwrap_or_default();
+ let lines = listing
+ .iter()
+ .map(|(gutter, message)| format!(" {gutter:>width$} warning: {message}"))
+ .collect::>()
+ .join("\n");
+ format!("\n{file}\n{lines}\n")
+}
+
+/// Group warnings by file, keeping each file's own source order.
+fn group(input: &CompilationInput, warnings: &[TypeWarning]) -> BTreeMap {
+ let mut grouped: BTreeMap = BTreeMap::new();
+ for warning in warnings {
+ let (file, gutter) = locate(input, warning);
+ grouped
+ .entry(file)
+ .or_default()
+ .push((gutter, warning.message.clone()));
+ }
+ grouped
+}
+
+/// A warning's file and `line:column` gutter, falling back to the unit's own
+/// label for a warning inference could not anchor to a position.
+fn locate(input: &CompilationInput, warning: &TypeWarning) -> (String, String) {
+ match warning.position {
+ Some(position) => {
+ let (file, line, column) = input.location(position);
+ (file, format!("{line}:{column}"))
+ }
+ None => (input.display_path().to_string(), String::from("-")),
+ }
+}
+
+/// The closing line: how many warnings there are and which rules raised them.
+fn summary(warnings: &[TypeWarning]) -> String {
+ let rules: BTreeSet<&str> = warnings.iter().map(|w| w.rule).collect();
+ let plural = if warnings.len() == 1 { "" } else { "s" };
+ format!(
+ "{} warning{plural} ({})",
+ warnings.len(),
+ rules.into_iter().collect::>().join(", ")
+ )
+}
+
+#[cfg(test)]
+mod tests {
+ use super::render;
+ use crate::project::CompilationInput;
+ use osprey_ast::Position;
+ use osprey_types::{TypeWarning, REDUNDANT_ANNOTATION};
+
+ /// A single-file unit whose warnings resolve against `main.osp`.
+ fn unit() -> CompilationInput {
+ let program = osprey_syntax::parse_program("let answer = 42\n").program;
+ CompilationInput::script("main.osp", String::new(), program)
+ }
+
+ fn warning(line: u32, column: u32, message: &str) -> TypeWarning {
+ TypeWarning {
+ message: message.to_string(),
+ position: Some(Position { line, column }),
+ rule: REDUNDANT_ANNOTATION,
+ }
+ }
+
+ #[test]
+ fn a_clean_program_renders_nothing_at_all() {
+ assert_eq!(render(&unit(), &[]), None);
+ }
+
+ #[test]
+ fn one_warning_renders_its_file_gutter_message_and_singular_summary() {
+ let raised = [warning(3, 4, "redundant return type annotation on `greet`")];
+ assert_eq!(
+ render(&unit(), &raised),
+ Some(
+ "\nmain.osp\n 3:4 warning: redundant return type annotation on `greet`\n\n1 warning (redundant-annotation)"
+ .to_string()
+ )
+ );
+ }
+
+ #[test]
+ fn gutters_are_right_aligned_so_messages_line_up() {
+ let raised = [warning(9, 1, "first"), warning(100, 12, "second")];
+ assert_eq!(
+ render(&unit(), &raised),
+ Some(
+ "\nmain.osp\n 9:1 warning: first\n 100:12 warning: second\n\n2 warnings (redundant-annotation)"
+ .to_string()
+ )
+ );
+ }
+
+ #[test]
+ fn a_positionless_warning_still_lists_under_its_unit() {
+ let raised = [TypeWarning {
+ message: String::from("nowhere in particular"),
+ position: None,
+ rule: REDUNDANT_ANNOTATION,
+ }];
+ assert_eq!(
+ render(&unit(), &raised),
+ Some(
+ "\nmain.osp\n - warning: nowhere in particular\n\n1 warning (redundant-annotation)"
+ .to_string()
+ )
+ );
+ }
+
+ #[test]
+ fn the_summary_lists_every_rule_that_fired_once_each() {
+ let raised = [
+ warning(1, 0, "a"),
+ warning(2, 0, "b"),
+ TypeWarning {
+ message: String::from("c"),
+ position: Some(Position { line: 3, column: 0 }),
+ rule: "some-other-rule",
+ },
+ ];
+ let text = render(&unit(), &raised).unwrap_or_default();
+ assert!(
+ text.ends_with("\n3 warnings (redundant-annotation, some-other-rule)"),
+ "{text}"
+ );
+ }
+}
diff --git a/crates/osprey-cli/src/wasm.rs b/crates/osprey-cli/src/wasm.rs
index d21fc9ad..0eacedbf 100644
--- a/crates/osprey-cli/src/wasm.rs
+++ b/crates/osprey-cli/src/wasm.rs
@@ -284,6 +284,7 @@ fn run_host(wasm: &Path) -> ExitCode {
#[cfg(test)]
mod tests {
use super::*;
+ use crate::testkit::shows;
/// Serializes tests that read/write process-global toolchain env vars
/// (`OSPREY_WASM_*`, `*_SYSROOT`) so they neither race each other nor the
@@ -336,9 +337,14 @@ mod tests {
fn entry_thunk_wraps_main_for_the_wasi_start_path() {
// [WASM-ENTRY]
let out = with_entry_thunk("define i32 @main() {\n ret i32 0\n}\n");
- assert!(out.contains("define i32 @main()"), "original main kept");
- assert!(out.contains("define i32 @__main_void()"), "thunk added");
- assert!(out.contains("call i32 @main()"), "thunk calls main");
+ shows(
+ &out,
+ &[
+ "define i32 @main()",
+ "define i32 @__main_void()",
+ "call i32 @main()",
+ ],
+ );
}
#[test]
@@ -346,9 +352,14 @@ mod tests {
// [WASM-WEB-ABI]
let mangled = format!("__osp_3x617070{WEB_DISPATCH_MANGLED_SUFFIX}");
let out = with_web_dispatch_thunk("; module", Some(&mangled));
- assert!(out.contains("define i64 @osprey_web_dispatch(i8* %message)"));
- assert!(out.contains(&format!("call i64 @{mangled}(i8* %message)")));
- assert!(out.contains("ret i64 %r"));
+ shows(
+ &out,
+ &[
+ "define i64 @osprey_web_dispatch(i8* %message)",
+ &format!("call i64 @{mangled}(i8* %message)"),
+ "ret i64 %r",
+ ],
+ );
let unchanged = with_web_dispatch_thunk("; module", Some(WEB_DISPATCH));
assert_eq!(unchanged, "; module", "source spelling needs no thunk");
diff --git a/crates/osprey-cli/tests/cli_e2e.rs b/crates/osprey-cli/tests/cli_e2e.rs
index 49a88d9f..151c760a 100644
--- a/crates/osprey-cli/tests/cli_e2e.rs
+++ b/crates/osprey-cli/tests/cli_e2e.rs
@@ -134,16 +134,27 @@ fn run_file_cc(path: &Path, mode: &str, cc: &str) -> Out {
finish(cmd)
}
-/// Type-clean but codegen-rejected: a still-generic lambda used as a bare
-/// VALUE has no ABI to fix and no call site to specialise against
-/// ([TYPE-GENERICS-FN]). It passes the type gate, so every compiling mode
-/// reaches codegen and fails there — exercising the `Err` arms
-/// `compile_program` feeds.
+/// Type-clean but codegen-rejected: an FFI callback slot is a raw C code
+/// pointer, so a capturing lambda has nowhere to carry its environment
+/// ([FFI-CALLBACKS]). It passes the type gate, so every compiling mode reaches
+/// codegen and fails there — exercising the `Err` arms `compile_program` feeds.
///
-/// This used to bind the value first (`let f = mk(1)` then `f(0)`). That shape
-/// now COMPILES: the returned lambda is inlined at each call site of the
-/// binding, so it no longer reaches a codegen error and could not exercise
-/// these arms.
+/// `(x + base) ?: 0` discharges the arithmetic `Result`; without it the lambda
+/// is `(int) -> Result` and the type gate rejects the call
+/// before codegen sees the capture.
+const CODEGEN_REJECTED: &str = concat!(
+ "extern fn registerCallback(cb: fn(int) -> int) -> int\n",
+ "let base = 10\n",
+ "let r = registerCallback(fn(x) => (x + base) ?: 0)\n",
+ "print(\"${r}\")\n",
+);
+
+/// A still-generic lambda used as a bare VALUE: no ABI to fix and no call site
+/// to specialise against ([TYPE-GENERICS-FN]).
+///
+/// This drove the two codegen-error tests until the checker learned to reject
+/// it, which is a strictly better place to catch it. It stays here to pin
+/// WHERE it is rejected, so the move cannot happen again unnoticed.
const GENERIC_AS_VALUE: &str = "fn mk(x: T) = |y| => x\nprint(\"${mk(1)}\")\n";
/// Explicit effect resume must run the rest of the handled computation and then
@@ -727,7 +738,7 @@ fn quiet_suppresses_the_ok_line() {
#[test]
fn llvm_reports_a_codegen_error() {
- let prog = temp_osp("cgllvm", GENERIC_AS_VALUE);
+ let prog = temp_osp("cgllvm", CODEGEN_REJECTED);
let o = run_file(&prog, &["--llvm"]);
assert_ne!(o.code, Some(0));
assert!(o.stderr.contains("codegen"), "{}", o.stderr);
@@ -735,12 +746,30 @@ fn llvm_reports_a_codegen_error() {
#[test]
fn run_reports_a_codegen_error() {
- let prog = temp_osp("cgrun", GENERIC_AS_VALUE);
+ let prog = temp_osp("cgrun", CODEGEN_REJECTED);
let o = run_file(&prog, &["--run"]);
assert_ne!(o.code, Some(0));
assert!(o.stderr.contains("codegen"), "{}", o.stderr);
}
+#[test]
+fn a_generic_closure_value_is_rejected_by_the_type_gate() {
+ // The two tests above assert a CODEGEN failure, so they go quiet the moment
+ // their input starts being rejected earlier — which is exactly what happened
+ // to this program. Pinning the checker's message here means a future move of
+ // the gate fails a test that names the gate, instead of silently draining
+ // the codegen arms of coverage.
+ let prog = temp_osp("genval", GENERIC_AS_VALUE);
+ let o = run_file(&prog, &["--llvm"]);
+ assert_ne!(o.code, Some(0));
+ assert!(
+ o.stderr
+ .contains("a closure value with a still-generic type cannot be interpolated"),
+ "{}",
+ o.stderr
+ );
+}
+
#[test]
fn compile_reports_a_failing_c_compiler() {
// `false` runs and exits non-zero -> the "cc failed to compile" branch.
@@ -1417,3 +1446,86 @@ fn error_result_assertions_render_the_error() {
);
assert!(o.stdout.contains("not ok 1 - div"), "{}", o.stdout);
}
+
+/// The whole call-site type-application pipeline — parse, check, lower, emit,
+/// link, run — for the shape that has no other spelling: a binder appearing in
+/// no parameter position. [TYPE-GENERICS-APPLY]
+#[test]
+fn a_written_type_argument_pins_an_instantiation_end_to_end() {
+ let prog = temp_osp(
+ "turbofish_run",
+ "fn identity(x: T) -> T = x\n\
+ fn emptyOf() -> List = []\n\
+ fn pickOf(first: T, second: U) -> T = first\n\
+ let n = identity(5)\n\
+ let s = identity(\"os\")\n\
+ let nested = length(identity>([1, 2]))\n\
+ let empty = length(emptyOf())\n\
+ let kept = pickOf(7, \"seven\")\n\
+ print(\"n=${n} s=${s} nested=${nested} empty=${empty} kept=${kept}\")\n",
+ );
+ let o = run_file(&prog, &["--run"]);
+ assert_eq!(o.code, Some(0), "stderr={}", o.stderr);
+ assert_eq!(o.stdout, "n=5 s=os nested=2 empty=0 kept=7\n");
+}
+
+/// The ML twin of the same program prints the same bytes ([FLAVOR-IR-EQUIV]).
+#[test]
+fn the_ml_written_type_argument_prints_the_same_bytes() {
+ let path = std::env::temp_dir().join("osprey_cli_e2e_turbofish_run_ml.ospml");
+ let _ = std::fs::write(
+ &path,
+ "identity : T -> T\n\
+ identity x = x\n\
+ emptyOf : Unit -> List\n\
+ emptyOf () = []\n\
+ pickOf : (T, U) -> T\n\
+ pickOf (first, second) = first\n\
+ n = identity 5\n\
+ s = identity \"os\"\n\
+ nested = length (identity> [1, 2])\n\
+ empty = length (emptyOf ())\n\
+ kept = pickOf (7, \"seven\")\n\
+ print \"n=${n} s=${s} nested=${nested} empty=${empty} kept=${kept}\"\n",
+ );
+ let o = run_file(&path, &["--run"]);
+ assert_eq!(o.code, Some(0), "stderr={}", o.stderr);
+ assert_eq!(o.stdout, "n=5 s=os nested=2 empty=0 kept=7\n");
+}
+
+/// A written list that misses the declared binder count is rejected before
+/// anything is emitted, naming both counts. [TYPE-GENERICS-APPLY]
+#[test]
+fn a_written_type_argument_count_mismatch_is_rejected_by_the_cli() {
+ let prog = temp_osp(
+ "turbofish_arity",
+ "fn identity(x: T) -> T = x\n\
+ print(\"${identity(5)}\")\n",
+ );
+ let o = run_file(&prog, &["--check"]);
+ assert_ne!(o.code, Some(0), "stdout={}", o.stdout);
+ assert!(
+ o.stderr
+ .contains("function `identity` takes 1 type argument(s), got 2"),
+ "stderr={}",
+ o.stderr
+ );
+}
+
+/// A written argument contradicting the value argument is a type error, not a
+/// silently ignored annotation. [TYPE-GENERICS-APPLY]
+#[test]
+fn a_contradicting_written_type_argument_is_rejected_by_the_cli() {
+ let prog = temp_osp(
+ "turbofish_contradiction",
+ "fn identity(x: T) -> T = x\n\
+ print(\"${identity(\\\"text\\\")}\")\n",
+ );
+ let o = run_file(&prog, &["--check"]);
+ assert_ne!(o.code, Some(0), "stdout={}", o.stdout);
+ assert!(
+ o.stderr.contains("cannot unify int with string"),
+ "stderr={}",
+ o.stderr
+ );
+}
diff --git a/crates/osprey-cli/tests/common/mod.rs b/crates/osprey-cli/tests/common/mod.rs
index 02280424..67ae8c5d 100644
--- a/crates/osprey-cli/tests/common/mod.rs
+++ b/crates/osprey-cli/tests/common/mod.rs
@@ -12,13 +12,13 @@ use std::path::{Path, PathBuf};
///
/// Left un-canonicalized on purpose: there is no fallible call to unwrap, and
/// the `..` components resolve the same way for every consumer here.
-pub fn repo_root() -> PathBuf {
+pub(crate) fn repo_root() -> PathBuf {
Path::new(env!("CARGO_MANIFEST_DIR")).join("..").join("..")
}
/// Every file with extension `ext` under `dir`, recursively, sorted so a
/// failure names the same program on every machine.
-pub fn sources(dir: &Path, ext: &str) -> Vec {
+pub(crate) fn sources(dir: &Path, ext: &str) -> Vec {
let mut out = Vec::new();
collect(dir, ext, &mut out);
out.sort();
@@ -47,7 +47,7 @@ fn collect(dir: &Path, ext: &str, out: &mut Vec) {
/// an instantiation that was never emitted collapsed onto one that was and the
/// gate reported a clean module — the exact dangling reference it exists to
/// catch ([`crate::monofn::specialize_callback`]).
-pub fn symbol_at(rest: &str) -> Option {
+pub(crate) fn symbol_at(rest: &str) -> Option {
let name: String = rest
.chars()
.take_while(|c| c.is_ascii_alphanumeric() || *c == '_' || *c == '.' || *c == '$')
@@ -57,7 +57,7 @@ pub fn symbol_at(rest: &str) -> Option {
}
/// Every `@symbol` the module BINDS — defined, declared or a global.
-pub fn bound_symbols(ir: &str) -> BTreeSet {
+pub(crate) fn bound_symbols(ir: &str) -> BTreeSet {
let mut bound = BTreeSet::new();
for line in ir.lines() {
let trimmed = line.trim_start();
@@ -83,7 +83,7 @@ pub fn bound_symbols(ir: &str) -> BTreeSet {
/// global initializer is a use like any other (`@table = global i8* @missing`),
/// and skipping the whole line let exactly that reference through: the one form
/// where a dangling symbol is written on the same line as a definition.
-pub fn undefined_symbols(ir: &str) -> BTreeSet {
+pub(crate) fn undefined_symbols(ir: &str) -> BTreeSet {
let bound = bound_symbols(ir);
let mut missing = BTreeSet::new();
for line in ir.lines() {
diff --git a/crates/osprey-cli/tests/common/staging.rs b/crates/osprey-cli/tests/common/staging.rs
index dc134847..f425a1e8 100644
--- a/crates/osprey-cli/tests/common/staging.rs
+++ b/crates/osprey-cli/tests/common/staging.rs
@@ -9,7 +9,7 @@ use osprey_syntax::{parse_program_with_flavor, Flavor};
/// Parse — which discharges static handlers at the flavor boundary
/// ([STAGE-LOWER-ORDER-PHASE]) — and emit LLVM IR.
-pub fn compile_staged(source: &str) -> String {
+pub(crate) fn compile_staged(source: &str) -> String {
let parsed = parse_program_with_flavor(source, Flavor::Default);
assert!(
parsed.errors.is_empty(),
@@ -22,7 +22,7 @@ pub fn compile_staged(source: &str) -> String {
}
/// Every diagnostic the frontend produces for `source`, joined for matching.
-pub fn diagnostics(source: &str, flavor: Flavor) -> String {
+pub(crate) fn diagnostics(source: &str, flavor: Flavor) -> String {
let parsed = parse_program_with_flavor(source, flavor);
if !parsed.errors.is_empty() {
return parsed
@@ -42,7 +42,7 @@ pub fn diagnostics(source: &str, flavor: Flavor) -> String {
/// Compile `source` for `target` through the real CLI, returning stderr and
/// whether it succeeded — the only path that runs the per-target capability
/// gate [MULTI-WASM] and [STAGE-WASM] are checked by.
-pub fn compile_for_target(source: &str, target: &str) -> (bool, String) {
+pub(crate) fn compile_for_target(source: &str, target: &str) -> (bool, String) {
let dir = std::env::temp_dir().join(format!(
"osprey_staged_{}_{:?}",
std::process::id(),
diff --git a/crates/osprey-cli/tests/staged_effects.rs b/crates/osprey-cli/tests/staged_effects.rs
index b3736d91..615eab91 100644
--- a/crates/osprey-cli/tests/staged_effects.rs
+++ b/crates/osprey-cli/tests/staged_effects.rs
@@ -11,7 +11,7 @@
#[path = "common/staging.rs"]
mod staging;
-use osprey_syntax::{dependency_sets, Flavor};
+use osprey_syntax::{dependency_report, Flavor};
use staging::{compile_for_target, compile_staged, diagnostics};
/// The C runtime symbols a dynamic handler region registers and looks up.
@@ -75,7 +75,7 @@ fn greeting() = "hello ${perform NameSignal.read()}"
fn statusBar() = "${greeting()} | ${counterLabel()}"
fn footer() = "osprey"
"#;
- let deps = dependency_sets(source, Flavor::Default);
+ let deps = dependency_report(source, Flavor::Default).0;
let of = |name: &str| deps.get(name).cloned().unwrap_or_default();
assert_eq!(of("doubled"), vec!["CountSignal.read"]);
// Transitive through a call, and only what is actually read.
@@ -101,7 +101,7 @@ fn root() = handle static CountSignal
read => 7
in label()
"#;
- let deps = dependency_sets(source, Flavor::Default);
+ let deps = dependency_report(source, Flavor::Default).0;
assert_eq!(
deps.get("label").cloned().unwrap_or_default(),
vec!["CountSignal.read"]
@@ -258,7 +258,7 @@ static effect Signal { read: fn() -> T }
fn counterLabel() = "count: ${(perform Signal.read()).value}"
fn cursorLabel() = "at: ${(perform Signal.read()).at}"
"#;
- let deps = dependency_sets(source, Flavor::Default);
+ let deps = dependency_report(source, Flavor::Default).0;
let of = |name: &str| deps.get(name).cloned().unwrap_or_default();
assert_eq!(
of("counterLabel"),
diff --git a/crates/osprey-codegen/src/aggregate.rs b/crates/osprey-codegen/src/aggregate.rs
index e1e76e16..60a18191 100644
--- a/crates/osprey-codegen/src/aggregate.rs
+++ b/crates/osprey-codegen/src/aggregate.rs
@@ -200,8 +200,7 @@ fn own_struct_handle(
obj: &str,
owner: impl Into,
) -> Value {
- let handle = cg.fresh_reg();
- cg.emit(format!("{handle} = bitcast {struct_ty}* {obj} to i8*"));
+ let handle = cg.emit_reg(format!("bitcast {struct_ty}* {obj} to i8*"));
let v = Value::handle(handle, owner);
crate::arc::own(cg, &v);
v
@@ -249,9 +248,8 @@ fn gen_http_response(cg: &mut Codegen, fields: &[FieldAssignment]) -> Result crate::cast::coerce_to(cg, v, LType::Str)?.operand,
};
crate::arc::dup_store(cg, llty, &operand);
- let p = cg.fresh_reg();
- cg.emit(format!(
- "{p} = getelementptr {HTTP_RESPONSE_STRUCT}, {HTTP_RESPONSE_STRUCT}* {obj}, i32 0, i32 {i}"
+ let p = cg.emit_reg(format!(
+ "getelementptr {HTTP_RESPONSE_STRUCT}, {HTTP_RESPONSE_STRUCT}* {obj}, i32 0, i32 {i}"
));
cg.emit(format!("store {llty} {operand}, {llty}* {p}"));
}
@@ -316,11 +314,7 @@ pub(crate) fn gen_update(
.ctor_struct_ty(&owner)
.ok_or_else(|| CodegenError::unknown(&owner))?;
- let src = cg.fresh_reg();
- cg.emit(format!(
- "{src} = bitcast i8* {} to {struct_ty}*",
- base.operand
- ));
+ let src = cg.emit_reg(format!("bitcast i8* {} to {struct_ty}*", base.operand));
// view.meta comes from the Osprey field types (builder.rs `field_meta`),
// which prove more than the erased LTypes visible here: an all-union field
// set upgrades to the probe-free KIND_MASK_DIRECT. noinit: the tag and every
@@ -347,6 +341,10 @@ pub(crate) fn gen_update(
/// load the field.
pub(crate) fn gen_field_access(cg: &mut Codegen, target: &Expr, field: &str) -> Result {
let tv = gen_expr(cg, target)?;
+ let inferred = tv
+ .inferred_type
+ .as_ref()
+ .and_then(|ty| cg.prog.field_type(ty, field));
// Use the statically-known owner (a named record or an anonymous object
// literal) when it actually declares `field`; otherwise (a generic accessor
// whose parameter infers to a type variable) resolve the field by name across
@@ -358,6 +356,14 @@ pub(crate) fn gen_field_access(cg: &mut Codegen, target: &Expr, field: &str) ->
let owner = known
.or_else(|| cg.find_field_owner(field))
.ok_or_else(|| CodegenError::invalid(format!("field `{field}` on a non-record")))?;
+ // Ordinary records can cross an inlined generic call with only their owner
+ // tag. Keep a concrete field's complete type, including every returned
+ // function arrow, so chained calls retain their ABI. [TYPE-FN-HIGHER-ORDER]
+ let inferred = inferred.or_else(|| {
+ cg.prog
+ .field_type(&osprey_types::Type::con(&owner, Vec::new()), field)
+ .filter(|ty| !osprey_types::has_type_var(ty))
+ });
if cg.ctor_field_result_inner(&owner, field).is_some() {
return Err(result_field_unsupported());
}
@@ -370,24 +376,32 @@ pub(crate) fn gen_field_access(cg: &mut Codegen, target: &Expr, field: &str) ->
.find_map(|(i, (f, t))| (f == field).then_some((i, *t)))
.ok_or_else(|| CodegenError::invalid(format!("`{owner}` has no field `{field}`")))?;
+ let fty = inferred.as_ref().map_or(fty, crate::types::ltype_of);
// A record that crossed a generic boundary — a list element, an inlined
// parameter whose type is still a variable — travels in the uniform machine
// word, so restore the handle before reading a slot out of it.
let tv = crate::cast::coerce_to(cg, tv, LType::Ptr)?;
- let src = cg.fresh_reg();
- cg.emit(format!(
- "{src} = bitcast i8* {} to {struct_ty}*",
- tv.operand
- ));
+ let src = cg.emit_reg(format!("bitcast i8* {} to {struct_ty}*", tv.operand));
let loaded = load_field(cg, &struct_ty, src.as_str(), idx + 1, fty);
// A handle field carries its ELEMENT's ABI, not an owner of its own: the
// slot holds a runtime id, and `recv`/`await` on it needs the element type
// to unbox with ([CONCURRENCY-CHANNEL]).
- if let Some(handle) = cg.ctor_field_handle(&owner, field) {
- return Ok(handle.restore(Value::new(loaded, fty)));
+ if let Some(handle) = inferred
+ .as_ref()
+ .and_then(|ty| crate::builder::FiberSig::of(&cg.prog, ty))
+ .or_else(|| cg.ctor_field_handle(&owner, field))
+ {
+ let mut value = handle.restore(Value::new(loaded, fty));
+ value.inferred_type = inferred;
+ return Ok(value);
}
- let owner = cg.ctor_field_owner(&owner, field);
- Ok(Value::new(loaded, fty).with_owner(owner))
+ let owner = inferred.as_ref().map_or_else(
+ || cg.ctor_field_owner(&owner, field),
+ |ty| crate::types::owner_name(&cg.prog, ty),
+ );
+ let mut value = Value::new(loaded, fty).with_owner(owner);
+ value.inferred_type = inferred;
+ Ok(value)
}
/// Aggregate layouts do not yet carry the shape metadata needed to preserve a
@@ -418,9 +432,8 @@ pub(crate) fn store_field(
if !moved {
crate::arc::dup_store(cg, fty.as_str(), val);
}
- let p = cg.fresh_reg();
- cg.emit(format!(
- "{p} = getelementptr {struct_ty}, {struct_ty}* {obj}, i32 0, i32 {idx}"
+ let p = cg.emit_reg(format!(
+ "getelementptr {struct_ty}, {struct_ty}* {obj}, i32 0, i32 {idx}"
));
cg.emit(format!("store {fty} {val}, {fty}* {p}"));
}
@@ -440,11 +453,9 @@ pub(crate) fn load_field(
idx: usize,
fty: LType,
) -> String {
- let p = cg.fresh_reg();
- cg.emit(format!(
- "{p} = getelementptr {struct_ty}, {struct_ty}* {obj}, i32 0, i32 {idx}"
+ let p = cg.emit_reg(format!(
+ "getelementptr {struct_ty}, {struct_ty}* {obj}, i32 0, i32 {idx}"
));
- let r = cg.fresh_reg();
- cg.emit(format!("{r} = load {fty}, {fty}* {p}"));
+ let r = cg.emit_reg(format!("load {fty}, {fty}* {p}"));
r
}
diff --git a/crates/osprey-codegen/src/builder.rs b/crates/osprey-codegen/src/builder.rs
index b7b9b285..656b1743 100644
--- a/crates/osprey-codegen/src/builder.rs
+++ b/crates/osprey-codegen/src/builder.rs
@@ -14,7 +14,7 @@ use std::fmt::Write as _;
/// Code generation switches that alter the emitted module without changing
/// Osprey semantics.
#[derive(Debug, Clone, Default)]
-pub struct CodegenOptions {
+pub(crate) struct CodegenOptions {
/// Source file identity used for LLVM/DWARF debug metadata.
pub debug_source: Option,
/// Instrument coverable lines with hit counters [TESTING-COVERAGE-CODEGEN].
@@ -26,11 +26,7 @@ pub struct CodegenOptions {
/// A lambda kept for inline application at its direct call sites: its
/// parameters, its body, and the position inference keyed its type by.
-pub(crate) type LambdaDef = (
- Vec,
- osprey_ast::Expr,
- Option,
-);
+pub(crate) type LambdaDef = (Vec, Expr, Option);
/// What the program turned out to CONTAIN — decided while lowering, read once
/// by `main`'s epilogue. These belong together because they are answered the
@@ -52,7 +48,7 @@ pub(crate) struct Lowered {
}
/// Accumulates a whole module while lowering one function at a time.
-pub struct Codegen {
+pub(crate) struct Codegen {
/// `declare` lines, de-duplicated and stably ordered.
externs: BTreeSet,
/// Global constant definitions (string literals).
@@ -74,6 +70,9 @@ pub struct Codegen {
/// Declared parameter names per function, for named-argument ordering.
pub(crate) fn_params: HashMap>,
+ /// Extern parameter names. Kept separate because `fn_params` also identifies
+ /// Osprey functions whose callbacks use closure cells rather than C pointers.
+ pub(crate) extern_params: HashMap>,
/// Type names an `extern fn` claims to return (every name in the declared
/// return type expression, conservatively). A foreign pointer typed as a
/// union would break the `KIND_MASK_DIRECT` all-children-are-ARC-bodies
@@ -145,7 +144,7 @@ pub struct Codegen {
/// function at each call site so its type variables monomorphize to the
/// concrete argument types there (specialisation by inlining rather than by
/// emitting a name-mangled copy per instantiation).
- pub(crate) fn_defs: HashMap, osprey_ast::Expr)>,
+ pub(crate) fn_defs: HashMap, Expr)>,
/// Generic functions currently being inlined — a re-entry guard so a
/// (mutually) recursive generic call falls back to a direct call instead of
/// inlining forever.
@@ -300,11 +299,12 @@ impl FiberSig {
}
}
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq)]
pub(crate) struct ParamSig {
pub(crate) ty: LType,
pub(crate) result_inner: Option,
pub(crate) fiber: Option,
+ pub(crate) inferred_type: Option,
}
impl ParamSig {
@@ -315,11 +315,13 @@ impl ParamSig {
ty: LType::Ptr,
result_inner: Some(inner),
fiber,
+ inferred_type: Some(ty.clone()),
},
None => Self {
ty: ltype_of(ty),
result_inner: None,
fiber,
+ inferred_type: Some(ty.clone()),
},
}
}
@@ -605,18 +607,18 @@ impl DebugState {
}
impl Codegen {
- pub fn new() -> Codegen {
+ pub(crate) fn new() -> Codegen {
Codegen::with_types(ProgramTypes::default())
}
/// Build with the inferred program types that drive parameter/return/value
/// typing.
- pub fn with_types(prog: ProgramTypes) -> Codegen {
+ pub(crate) fn with_types(prog: ProgramTypes) -> Codegen {
Codegen::with_options(prog, CodegenOptions::default())
}
/// Build with inferred program types and explicit code generation options.
- pub fn with_options(prog: ProgramTypes, options: CodegenOptions) -> Codegen {
+ pub(crate) fn with_options(prog: ProgramTypes, options: CodegenOptions) -> Codegen {
Codegen {
externs: BTreeSet::new(),
globals: Vec::new(),
@@ -631,6 +633,7 @@ impl Codegen {
scope_ids: Vec::new(),
next_scope_id: 0,
fn_params: HashMap::new(),
+ extern_params: HashMap::new(),
extern_ret_types: BTreeSet::new(),
nullary_singletons: HashMap::new(),
prog,
@@ -702,6 +705,11 @@ impl Codegen {
/// [TYPE-FN-HIGHER-ORDER].
pub(crate) fn callee_fn_type(&self, expr: &Expr) -> Option {
match expr {
+ Expr::TypeApply {
+ function, position, ..
+ } => self
+ .callee_fn_type(function)
+ .map(|ty| self.prog.application_type(*position, &ty)),
Expr::Identifier(name) => self.identifier_fn_type(name),
// A call evaluates to its callee's return type — recurse so a chain
// peels one arrow per application.
@@ -747,13 +755,7 @@ impl Codegen {
/// unique field-name match across known layouts.
fn field_fn_type(&self, target: &Expr, field: &str) -> Option {
let owner = self.callee_field_owner(target, field)?;
- self.prog
- .ctors
- .get(&owner)?
- .fields
- .iter()
- .find(|(f, _)| f == field)
- .map(|(_, t)| t.clone())
+ self.ctor_field_ty(&owner, field).cloned()
}
/// Resolve the owner type of `target.field`: prefer a bound identifier's
@@ -770,12 +772,21 @@ impl Codegen {
self.find_field_owner(field)
}
- /// Whether `owner`'s layout declares `field`.
- fn declares_field(&self, owner: &str, field: &str) -> bool {
+ /// The declared type of `field` on constructor `owner` — the single field
+ /// lookup behind [`Self::declares_field`] and every `ctor_field_*` accessor.
+ fn ctor_field_ty(&self, owner: &str, field: &str) -> Option<&Type> {
self.prog
.ctors
- .get(owner)
- .is_some_and(|c| c.fields.iter().any(|(f, _)| f == field))
+ .get(owner)?
+ .fields
+ .iter()
+ .find(|(f, _)| f == field)
+ .map(|(_, t)| t)
+ }
+
+ /// Whether `owner`'s layout declares `field`.
+ fn declares_field(&self, owner: &str, field: &str) -> bool {
+ self.ctor_field_ty(owner, field).is_some()
}
/// Whether `name` is a user function whose inferred signature still contains
@@ -979,7 +990,7 @@ impl Codegen {
pub(crate) fn fn_ret_is_unit(&self, name: &str) -> bool {
self.prog
.return_type(name)
- .is_some_and(|t| *t == osprey_types::Type::unit())
+ .is_some_and(|t| *t == Type::unit())
}
/// The LLVM parameter types of a user function, from inference.
@@ -1076,7 +1087,7 @@ impl Codegen {
/// smuggle in a foreign pointer and break the proof. Everything else
/// (strings can be rodata, records can cross the C ABI, `Ptr` is FFI)
/// keeps the probe-tolerant `LType` mapping. [GC-ARC-PERCEUS]
- fn field_meta(&self, t: &osprey_types::Type) -> crate::meta::MetaField {
+ fn field_meta(&self, t: &Type) -> crate::meta::MetaField {
let proven = crate::types::proven_heap_name(t).is_some_and(|n| {
self.prog.unions.contains_key(n) && !self.extern_ret_types.contains(n)
});
@@ -1164,14 +1175,7 @@ impl Codegen {
.find(|(f, _, _)| f == field)
.and_then(|(_, _, tag)| tag.clone());
}
- let ty = self
- .prog
- .ctors
- .get(owner)?
- .fields
- .iter()
- .find(|(f, _)| f == field)
- .map(|(_, t)| t.clone())?;
+ let ty = self.ctor_field_ty(owner, field)?.clone();
let head = crate::types::owner_name(&self.prog, &ty)?;
let known = self.prog.ctors.contains_key(&head)
|| self.prog.unions.contains_key(&head)
@@ -1190,30 +1194,16 @@ impl Codegen {
/// read the wire word raw and the element came back untyped.
/// Implements [CONCURRENCY-CHANNEL].
pub(crate) fn ctor_field_handle(&self, owner: &str, field: &str) -> Option {
- let ty = self
- .prog
- .ctors
- .get(owner)?
- .fields
- .iter()
- .find(|(name, _)| name == field)
- .map(|(_, ty)| ty)?;
- FiberSig::of(&self.prog, ty)
+ FiberSig::of(&self.prog, self.ctor_field_ty(owner, field)?)
}
pub(crate) fn ctor_field_result_inner(&self, owner: &str, field: &str) -> Option {
- self.prog
- .ctors
- .get(owner)?
- .fields
- .iter()
- .find(|(name, _)| name == field)
- .and_then(|(_, ty)| crate::types::result_inner(ty))
+ crate::types::result_inner(self.ctor_field_ty(owner, field)?)
}
/// The variant constructor names of a union owner, in tag order.
pub(crate) fn union_variants(&self, owner: &str) -> Option<&[String]> {
- self.prog.unions.get(owner).map(std::vec::Vec::as_slice)
+ self.prog.unions.get(owner).map(Vec::as_slice)
}
// ---- SSA + block naming (function-local) ----
@@ -1246,6 +1236,17 @@ impl Codegen {
/// Emit `r = {rhs}` to a fresh SSA register and return `r` — the ubiquitous
/// "name the result of one instruction" step (`zext …`, `icmp …`, `fneg …`).
+ /// Open a diamond on `cond`: mint the two arm labels plus the join they
+ /// both reach, and emit the branch between them. Answers
+ /// `(true_arm, false_arm, join)`; the caller starts whichever arm it means
+ /// to fill first. Minting labels apart from the `br` that names them is how
+ /// a block ends up unterminated, so the two steps are one call.
+ pub(crate) fn diamond(&mut self, cond: &str) -> (String, String, String) {
+ let (taken, other, join) = (self.fresh_label(), self.fresh_label(), self.fresh_label());
+ self.emit(format!("br i1 {cond}, label %{taken}, label %{other}"));
+ (taken, other, join)
+ }
+
pub(crate) fn emit_reg(&mut self, rhs: impl std::fmt::Display) -> String {
let r = self.fresh_reg();
self.emit(format!("{r} = {rhs}"));
@@ -1297,8 +1298,7 @@ impl Codegen {
};
self.add_extern("declare void @llvm.dbg.declare(metadata, metadata, metadata)");
let ty = value.ty.as_str();
- let slot = self.fresh_reg();
- self.emit(format!("{slot} = alloca {ty}"));
+ let slot = self.emit_reg(format!("alloca {ty}"));
self.emit(format!("store {ty} {}, {ty}* {slot}", value.operand));
self.emit(format!(
"call void @llvm.dbg.declare(metadata {ty}* {slot}, metadata !{var_id}, metadata !DIExpression())"
@@ -1369,9 +1369,8 @@ impl Codegen {
self.globals.push(format!(
"{name} = private unnamed_addr constant [{len} x i8] c\"{escaped}\""
));
- let reg = self.fresh_reg();
- self.emit(format!(
- "{reg} = getelementptr [{len} x i8], [{len} x i8]* {name}, i64 0, i64 0"
+ let reg = self.emit_reg(format!(
+ "getelementptr [{len} x i8], [{len} x i8]* {name}, i64 0, i64 0"
));
let _ = self.rodata_regs.insert(reg.clone());
Value::new(reg, LType::Str)
@@ -1610,19 +1609,16 @@ impl Codegen {
}
fn malloc_struct_with(&mut self, struct_ty: &str, meta: i64, noinit: bool) -> String {
- let szp = self.fresh_reg();
- self.emit(format!(
- "{szp} = getelementptr {struct_ty}, {struct_ty}* null, i64 1"
+ let szp = self.emit_reg(format!(
+ "getelementptr {struct_ty}, {struct_ty}* null, i64 1"
));
- let sz = self.fresh_reg();
- self.emit(format!("{sz} = ptrtoint {struct_ty}* {szp} to i64"));
+ let sz = self.emit_reg(format!("ptrtoint {struct_ty}* {szp} to i64"));
let raw = if noinit {
self.heap_alloc_tagged_noinit(&sz, meta)
} else {
self.heap_alloc_tagged(&sz, meta)
};
- let obj = self.fresh_reg();
- self.emit(format!("{obj} = bitcast i8* {raw} to {struct_ty}*"));
+ let obj = self.emit_reg(format!("bitcast i8* {raw} to {struct_ty}*"));
obj
}
diff --git a/crates/osprey-codegen/src/call.rs b/crates/osprey-codegen/src/call.rs
index 7a4cec0e..457858ab 100644
--- a/crates/osprey-codegen/src/call.rs
+++ b/crates/osprey-codegen/src/call.rs
@@ -31,8 +31,7 @@ impl Codegen {
/// result register `r`.
pub(crate) fn call(&mut self, ret: &str, cname: &str, params: &str, args: &[&str]) -> String {
let typed = declare_and_args(self, ret, cname, params, args);
- let r = self.fresh_reg();
- self.emit(format!("{r} = call {ret} @{cname}({typed})"));
+ let r = self.emit_reg(format!("call {ret} @{cname}({typed})"));
r
}
diff --git a/crates/osprey-codegen/src/cast.rs b/crates/osprey-codegen/src/cast.rs
index dbaafff7..8fb9dcde 100644
--- a/crates/osprey-codegen/src/cast.rs
+++ b/crates/osprey-codegen/src/cast.rs
@@ -49,8 +49,7 @@ pub(crate) fn coerce_to(cg: &mut Codegen, v: Value, want: LType) -> Result,
) -> Value {
+ let owner = owner.or_else(|| {
+ sig.inferred_type
+ .as_ref()
+ .and_then(|ty| crate::types::owner_name(&cg.prog, ty))
+ });
// A handle parameter's `owner` slot carries its ELEMENT's tag, not its own
// — a fiber or channel id is a machine word with nothing to own.
let (own_tag, elem_tag) = match sig.fiber {
Some(_) => (None, owner),
None => (owner, None),
};
- let value = if let Some(inner) = sig.result_inner {
+ let mut value = if let Some(inner) = sig.result_inner {
let struct_ty = crate::llty::result_struct_ty(inner);
let typed = cg.emit_reg(format!("bitcast i8* {operand} to {struct_ty}*"));
Value::result(typed, inner)
} else {
Value::new(operand, sig.ty).with_owner(own_tag)
};
+ value.inferred_type = sig.inferred_type;
match sig.fiber {
Some(fiber) => {
let mut restored = fiber.restore(value);
- restored.fiber_elem_owner = elem_tag;
+ restored.fiber_elem_owner = elem_tag.or(restored.fiber_elem_owner);
restored
}
None => value,
diff --git a/crates/osprey-codegen/src/closure.rs b/crates/osprey-codegen/src/closure.rs
index 1c422b1a..3d8c750f 100644
--- a/crates/osprey-codegen/src/closure.rs
+++ b/crates/osprey-codegen/src/closure.rs
@@ -54,7 +54,10 @@ pub(crate) fn lambda_value(
}
let sig = Codegen::fn_value_sig(&cg.prog, ty)
.ok_or_else(|| CodegenError::invalid("lambda has no inferred function type"))?;
- emit_closure(cg, parameters, body, &sig)
+ let ty = ty.clone();
+ let mut value = emit_closure(cg, parameters, body, &sig)?;
+ value.inferred_type = Some(ty);
+ Ok(value)
}
/// Emit a lambda as a closure value with the given signature (the consuming
@@ -130,10 +133,7 @@ pub(crate) fn specialisation_key(target: &str, sig: &FnSig) -> String {
let semantic_params = sig
.0
.iter()
- .map(|param| match param.result_inner {
- Some(inner) => format!("Result<{inner}>"),
- None => param.ty.to_string(),
- })
+ .map(|param| format!("{param:?}"))
.collect::>()
.join(",");
format!(
@@ -214,6 +214,9 @@ pub(crate) fn bind_params_from(
for (i, (p, pty)) in parameters.iter().zip(param_tys).enumerate() {
let reg = crate::llty::param_register(first + i);
let value = crate::cast::incoming_param(cg, format!("%{reg}"), pty.clone(), None);
+ if let Some(ty) = &value.inferred_type {
+ cg.bind_fn_local(&p.name, ty.clone());
+ }
cg.bind(p.name.clone(), value);
out.push((pty.ty, reg));
}
@@ -236,6 +239,9 @@ pub(crate) fn reload_captures(cg: &mut Codegen, cell_ty: &str, caps: &[Capture])
let r = cg.emit_reg(format!("load {lty}, {lty}* {p}"));
let mut v = c.val.clone();
v.operand = r;
+ if let Some(ty) = &v.inferred_type {
+ cg.bind_fn_local(&c.name, ty.clone());
+ }
cg.bind(c.name.clone(), v);
}
}
@@ -373,7 +379,17 @@ pub(crate) fn cell_call_exprs(
for e in exprs {
vals.push(gen_expr(cg, e)?);
}
- let typed = coerce_closure_args(cg, sig, vals)?;
+ cell_call_values(cg, handle, sig, vals)
+}
+
+/// Call using values already lowered against their semantic parameter types.
+pub(crate) fn cell_call_values(
+ cg: &mut Codegen,
+ handle: &str,
+ sig: &FnSig,
+ values: Vec,
+) -> Result {
+ let typed = coerce_closure_args(cg, sig, values)?;
Ok(cell_call(cg, handle, sig, &typed))
}
@@ -421,17 +437,37 @@ pub(crate) fn returned(reg: String, sig: &FnSig) -> Value {
/// module) a forwarder that drops the env argument and tail-calls the real
/// function, plus a constant cell pointing at it.
pub(crate) fn named_fn_cell(cg: &mut Codegen, name: &str) -> Result {
- if cg.fn_defs.contains_key(name) {
- return Err(CodegenError::unsupported(
- "a generic function as a function value",
- ));
+ if let Some((parameters, body)) = cg.fn_defs.get(name).cloned() {
+ return specialized_named_cell(cg, name, ¶meters, &body);
}
let cell = match cg.fnval_cells.get(name) {
Some(g) => g.clone(),
None => emit_forwarder(cg, name)?,
};
let reg = cg.emit_reg(format!("bitcast {{ i8* }}* {cell} to i8*"));
- Ok(Value::new(reg, LType::Ptr))
+ let mut value = Value::new(reg, LType::Ptr);
+ value.inferred_type = cg.callee_fn_type(&Expr::Identifier(name.to_owned()));
+ Ok(value)
+}
+
+fn specialized_named_cell(
+ cg: &mut Codegen,
+ name: &str,
+ parameters: &[Parameter],
+ body: &Expr,
+) -> Result {
+ let ty = cg.callee_fn_type(&Expr::Identifier(name.to_owned()));
+ let Some(ty) = ty.filter(crate::types::fn_value_concrete) else {
+ return Err(CodegenError::unsupported(
+ "a generic function as a function value",
+ ));
+ };
+ let sig = Codegen::fn_value_sig(&cg.prog, &ty)
+ .ok_or_else(|| CodegenError::invalid("function value has no signature"))?;
+ let key = format!("{}|{ty:?}", specialisation_key(name, &sig));
+ let mut value = emit_closure_keyed(cg, parameters, body, &sig, Some(key))?;
+ value.inferred_type = Some(ty);
+ Ok(value)
}
/// Emit `@__fnval_{name}` (env-dropping forwarder) and its constant cell;
diff --git a/crates/osprey-codegen/src/collections.rs b/crates/osprey-codegen/src/collections.rs
index 1d6b1c8e..5eb2943e 100644
--- a/crates/osprey-codegen/src/collections.rs
+++ b/crates/osprey-codegen/src/collections.rs
@@ -168,8 +168,7 @@ pub(crate) fn gen_receiver_directed(
},
};
Ok(Some(if name == "isEmpty" {
- let r = cg.fresh_reg();
- cg.emit(format!("{r} = icmp eq i64 {}, 0", count.operand));
+ let r = cg.emit_reg(format!("icmp eq i64 {}, 0", count.operand));
Value::new(r, LType::I1)
} else {
count
@@ -379,15 +378,13 @@ fn list_contains(cg: &mut Codegen, args: &[Expr]) -> Result {
let is_str = needle.ty == LType::Str;
let boxed = box_to_i64(cg, needle.clone());
- let res = cg.fresh_reg();
- cg.emit(format!("{res} = alloca i1"));
+ let res = cg.emit_reg("alloca i1");
cg.emit(format!("store i1 0, i1* {res}"));
let lp = open_list_loop(cg, &l.operand);
let eq = cg.fresh_reg();
if is_str {
- let ep = cg.fresh_reg();
- cg.emit(format!("{ep} = inttoptr i64 {} to i8*", lp.elem));
+ let ep = cg.emit_reg(format!("inttoptr i64 {} to i8*", lp.elem));
let c = cg.call("i32", "strcmp", "i8*, i8*", &[&ep, &needle.operand]);
cg.emit(format!("{eq} = icmp eq i32 {c}, 0"));
} else {
@@ -402,8 +399,7 @@ fn list_contains(cg: &mut Codegen, args: &[Expr]) -> Result {
cg.start_block(&cont);
close_list_loop(cg, &lp);
- let out = cg.fresh_reg();
- cg.emit(format!("{out} = load i1, i1* {res}"));
+ let out = cg.emit_reg(format!("load i1, i1* {res}"));
Ok(Value::new(out, LType::I1))
}
@@ -453,8 +449,7 @@ fn map_contains(cg: &mut Codegen, args: &[Expr]) -> Result {
"i8*, i64",
&[&m.operand, &k.operand],
);
- let r = cg.fresh_reg();
- cg.emit(format!("{r} = icmp ne i32 {raw}, 0"));
+ let r = cg.emit_reg(format!("icmp ne i32 {raw}, 0"));
Ok(Value::new(r, LType::I1))
}
@@ -536,10 +531,8 @@ fn map_to_list(cg: &mut Codegen, args: &[Expr], take_key: bool) -> Result
let managed = cg.call("i32", kind, "i8*", &[&m.operand]);
let bld = list_builder_new_of(cg, &managed);
let iter = cg.call("i8*", "osprey_map_iter_new", "i8*", &[&m.operand]);
- let kp = cg.fresh_reg();
- cg.emit(format!("{kp} = alloca i64"));
- let vp = cg.fresh_reg();
- cg.emit(format!("{vp} = alloca i64"));
+ let kp = cg.emit_reg("alloca i64");
+ let vp = cg.emit_reg("alloca i64");
let cond = cg.fresh_label();
let body = cg.fresh_label();
@@ -553,14 +546,12 @@ fn map_to_list(cg: &mut Codegen, args: &[Expr], take_key: bool) -> Result
"i8*, i64*, i64*",
&[&iter, &kp, &vp],
);
- let more = cg.fresh_reg();
- cg.emit(format!("{more} = icmp ne i32 {has}, 0"));
+ let more = cg.emit_reg(format!("icmp ne i32 {has}, 0"));
cg.emit(format!("br i1 {more}, label %{body}, label %{endl}"));
cg.start_block(&body);
let slot = if take_key { &kp } else { &vp };
- let elem = cg.fresh_reg();
- cg.emit(format!("{elem} = load i64, i64* {slot}"));
+ let elem = cg.emit_reg(format!("load i64, i64* {slot}"));
list_builder_push_borrowed(cg, &bld, &elem);
cg.emit(format!("br label %{cond}"));
diff --git a/crates/osprey-codegen/src/curry.rs b/crates/osprey-codegen/src/curry.rs
index 7656b973..9a6e7b07 100644
--- a/crates/osprey-codegen/src/curry.rs
+++ b/crates/osprey-codegen/src/curry.rs
@@ -12,11 +12,17 @@ use crate::builder::Codegen;
use crate::error::Result;
use crate::expr::gen_expr;
use crate::llty::Value;
-use osprey_ast::{Expr, NamedArgument};
+use osprey_ast::{Expr, NamedArgument, Position};
/// One application group of a spine: `f(a, b)(c)` has groups `[a, b]`, `[c]`.
pub(crate) type ArgGroup<'a> = (&'a [Expr], &'a [NamedArgument]);
+struct Spine<'a> {
+ head: &'a str,
+ application: Option,
+ groups: Vec>,
+}
+
/// Lower `function(arguments)` when `function` is itself an application spine
/// headed by a generic user function — `None` when it is anything else, so the
/// ordinary call paths keep precedence.
@@ -26,7 +32,12 @@ pub(crate) fn try_spine(
arguments: &[Expr],
named: &[NamedArgument],
) -> Result> {
- let Some((head, mut groups)) = spine(function) else {
+ let Some(Spine {
+ head,
+ application,
+ mut groups,
+ }) = spine(function)
+ else {
return Ok(None);
};
if !cg.fn_defs.contains_key(head) {
@@ -36,16 +47,25 @@ pub(crate) fn try_spine(
let Some((first, rest)) = groups.split_first() else {
return Ok(None);
};
- crate::genfn::try_inline(cg, head, first.0, first.1, rest)
+ crate::expr::with_application(cg, application, |cg| {
+ crate::genfn::try_inline(cg, head, first.0, first.1, rest)
+ })
}
/// Flatten an application spine into its head identifier and argument groups,
/// outermost group last. `None` when the head is not a bare name.
-fn spine(expr: &Expr) -> Option<(&str, Vec>)> {
+fn spine(expr: &Expr) -> Option> {
let mut groups = Vec::new();
let mut node = expr;
+ let mut application = None;
loop {
match node {
+ Expr::TypeApply {
+ function, position, ..
+ } => {
+ application = *position;
+ node = function;
+ }
Expr::Call {
function,
arguments,
@@ -56,7 +76,11 @@ fn spine(expr: &Expr) -> Option<(&str, Vec>)> {
}
Expr::Identifier(name) => {
groups.reverse();
- return Some((name.as_str(), groups));
+ return Some(Spine {
+ head: name,
+ application,
+ groups,
+ });
}
_ => return None,
}
diff --git a/crates/osprey-codegen/src/effects.rs b/crates/osprey-codegen/src/effects.rs
index f4e9d065..800d09e6 100644
--- a/crates/osprey-codegen/src/effects.rs
+++ b/crates/osprey-codegen/src/effects.rs
@@ -15,7 +15,7 @@ use crate::expr::gen_expr;
use crate::llty::{LType, Value};
use crate::types::{ltype_of, result_inner};
use osprey_ast::freevars::free_idents;
-use osprey_ast::{contains_resume, Expr, HandlerArm, MatchArm, Stmt};
+use osprey_ast::{contains_resume, AstNode, Expr, HandlerArm, Stmt};
use osprey_types::ProgramTypes;
use std::collections::{BTreeSet, HashSet};
@@ -41,6 +41,7 @@ impl OpSig {
ty: LType::I64,
result_inner: None,
fiber: None,
+ inferred_type: None,
}
}
@@ -236,8 +237,7 @@ fn emit_unhandled_guard(cg: &mut Codegen, raw: &str, lookup_key: &str, operation
"br i1 {is_null}, label %{abort_lbl}, label %{ok_lbl}"
));
cg.start_block(&abort_lbl);
- let p = cg.fresh_reg();
- cg.emit(format!("{p} = call i32 @puts(i8* {})", msg.operand));
+ let _ = cg.emit_reg(format!("call i32 @puts(i8* {})", msg.operand));
cg.emit("call void @exit(i32 1)");
cg.emit("unreachable");
cg.start_block(&ok_lbl);
@@ -280,133 +280,21 @@ pub(crate) fn captured_mut_vars_in_stmts(stmts: &[&Stmt]) -> HashSet {
muts.intersection(&captured).cloned().collect()
}
-// A purpose-built AST walk (parallel in *shape* to `freevars::walk`, but
-// collecting two different sets: every mutable binding and the names handler
-// arms reference freely). The handler-arm free idents themselves come from
-// `free_idents` so that one definition of "what does this close over" stays in
-// `freevars`; only the find-the-handlers/muts traversal lives here.
+// Capture rules stay local; structural child enumeration is shared with the
+// other AST passes so new expression variants have one traversal table.
fn scan_expr(e: &Expr, muts: &mut BTreeSet, captured: &mut BTreeSet) {
- match e {
- Expr::Handler { arms, body, .. } => {
- for arm in arms {
- captured.extend(arm_free_idents(arm));
- scan_expr(&arm.body, muts, captured);
- }
- scan_expr(body, muts, captured);
- }
- Expr::Block { statements, value } => {
- for s in statements {
- scan_stmt(s, muts, captured);
- }
- if let Some(v) = value {
- scan_expr(v, muts, captured);
- }
+ if let Expr::Handler { arms, .. } = e {
+ for arm in arms {
+ captured.extend(arm_free_idents(arm));
}
- Expr::Match { value, arms } => {
- scan_expr(value, muts, captured);
- scan_arms(arms, muts, captured);
- }
- Expr::Select { arms } => scan_arms(arms, muts, captured),
- _ => scan_children(e, muts, captured),
}
-}
-
-fn scan_arms(arms: &[MatchArm], muts: &mut BTreeSet, captured: &mut BTreeSet) {
- scan_slice(arms, muts, captured, |arm| &arm.body);
-}
-
-/// Recurse into every child expression of `e` (the variants that are not
-/// special-cased in [`scan_expr`]), so a handler/mut nested anywhere is found.
-fn scan_children(e: &Expr, muts: &mut BTreeSet, captured: &mut BTreeSet) {
- match e {
- Expr::InterpolatedStr(parts) => {
- for p in parts {
- if let osprey_ast::InterpolatedPart::Expr(x) = p {
- scan_expr(x, muts, captured);
- }
- }
- }
- Expr::List(xs, _) => scan_slice(xs, muts, captured, |x| x),
- Expr::Map(es) => {
- for en in es {
- scan_expr(&en.key, muts, captured);
- scan_expr(&en.value, muts, captured);
- }
- }
- Expr::Object(fs)
- | Expr::TypeConstructor { fields: fs, .. }
- | Expr::Update { fields: fs, .. } => {
- scan_slice(fs, muts, captured, |f| &f.value);
- }
- Expr::Binary { left, right, .. } | Expr::Pipe { left, right } => {
- scan_expr(left, muts, captured);
- scan_expr(right, muts, captured);
- }
- Expr::Unary { operand, .. } => scan_expr(operand, muts, captured),
- Expr::Call {
- function,
- arguments,
- named_arguments,
- } => {
- scan_expr(function, muts, captured);
- scan_args(arguments, named_arguments, muts, captured);
- }
- Expr::MethodCall {
- target,
- arguments,
- named_arguments,
- ..
- } => {
- scan_expr(target, muts, captured);
- scan_args(arguments, named_arguments, muts, captured);
- }
- Expr::FieldAccess { target, .. } => scan_expr(target, muts, captured),
- Expr::Index { target, index } => {
- scan_expr(target, muts, captured);
- scan_expr(index, muts, captured);
- }
- Expr::Lambda { body, .. } | Expr::Spawn(body) | Expr::Await(body) | Expr::Recv(body) => {
- scan_expr(body, muts, captured);
- }
- Expr::Yield(Some(x)) => scan_expr(x, muts, captured),
- Expr::Send { channel, value } => {
- scan_expr(channel, muts, captured);
- scan_expr(value, muts, captured);
- }
- Expr::Perform {
- arguments,
- named_arguments,
- ..
- } => scan_args(arguments, named_arguments, muts, captured),
- Expr::Resume(Some(value)) => scan_expr(value, muts, captured),
- _ => {}
+ // Preserve this collector's existing exclusion of specialized operands.
+ if matches!(e, Expr::TypeApply { .. }) {
+ return;
}
-}
-
-/// Scan a callee-style argument list: positional arguments then the named
-/// ones, in source order. Shared by every call-shaped node (call, method call,
-/// `perform`) so none of them can forget a half.
-fn scan_args(
- arguments: &[Expr],
- named_arguments: &[osprey_ast::NamedArgument],
- muts: &mut BTreeSet,
- captured: &mut BTreeSet,
-) {
- scan_slice(arguments, muts, captured, |x| x);
- scan_slice(named_arguments, muts, captured, |n| &n.value);
-}
-
-/// Recurse into each element of `items`, projecting it to its sub-expression
-/// with `pick`. The one place the effect scanner fans out over a collection
-/// node, threading `muts`/`captured` through [`osprey_ast::walk_each`].
-fn scan_slice(
- items: &[T],
- muts: &mut BTreeSet,
- captured: &mut BTreeSet,
- pick: impl Fn(&T) -> &Expr,
-) {
- osprey_ast::walk_each(items, &mut (muts, captured), pick, |e, (m, c)| {
- scan_expr(e, m, c);
+ AstNode::Expression(e).for_each_child(|child| match child {
+ AstNode::Statement(statement) => scan_stmt(statement, muts, captured),
+ AstNode::Expression(expression) => scan_expr(expression, muts, captured),
});
}
@@ -464,14 +352,9 @@ pub(crate) fn gen_handler(
emit_handler_fn(cg, &fn_name, arm, &sig, resolved, &caps, &env_ty)?;
let eff_s = cg.string_constant(&key);
let op_s = cg.string_constant(&arm.operation);
- let fp = cg.fresh_reg();
- cg.emit(format!(
- "{fp} = bitcast {} @{fn_name} to i8*",
- sig.fn_ptr_ty()
- ));
- let r = cg.fresh_reg();
- cg.emit(format!(
- "{r} = call i32 @__osprey_handler_push(i8* {}, i8* {}, i8* {fp}, i8* {env})",
+ let fp = cg.emit_reg(format!("bitcast {} @{fn_name} to i8*", sig.fn_ptr_ty()));
+ let _ = cg.emit_reg(format!(
+ "call i32 @__osprey_handler_push(i8* {}, i8* {}, i8* {fp}, i8* {env})",
eff_s.operand, op_s.operand
));
}
@@ -479,8 +362,7 @@ pub(crate) fn gen_handler(
let result = gen_expr(cg, body)?;
for _ in arms {
- let r = cg.fresh_reg();
- cg.emit(format!("{r} = call i32 @__osprey_handler_pop()"));
+ let _ = cg.emit_reg("call i32 @__osprey_handler_pop()");
}
// The popped region's env reached its structural end: drop it (its mask
// releases the captured values) [GC-ARC-PERCEUS].
@@ -707,23 +589,28 @@ fn coerce_to_op_result(
result_inner: Option,
) -> Result {
match result_inner {
- Some(inner) if value.result_inner.is_some() => {
- crate::result::repack_to_inner(cg, value, inner)
- }
- Some(inner) => crate::result::make_ok(cg, value, inner),
+ Some(inner) => promote_to_result(cg, value, inner),
None => coerce_to(cg, value, ret_ty),
}
}
+/// Carry `value` into a `Result` answer slot: repack one that is
+/// already a Result, else apply the language's safe `T -> Success(T)`
+/// promotion. Never erases a discriminant.
+fn promote_to_result(cg: &mut Codegen, value: Value, inner: LType) -> Result {
+ if value.result_inner.is_some() {
+ crate::result::repack_to_inner(cg, value, inner)
+ } else {
+ crate::result::make_ok(cg, value, inner)
+ }
+}
+
/// Coerce an arm answer without ever erasing a Result. The only
/// representation-changing coercion allowed here is the language's safe
/// `T -> Success(T)` promotion when the handled expression itself is Result.
fn coerce_to_answer(cg: &mut Codegen, value: Value, answer: &AnswerShape) -> Result {
match answer.result_inner {
- Some(inner) if value.result_inner.is_some() => {
- crate::result::repack_to_inner(cg, value, inner)
- }
- Some(inner) => crate::result::make_ok(cg, value, inner),
+ Some(inner) => promote_to_result(cg, value, inner),
// An arm that does not `resume` abandons the continuation, so ITS value
// becomes the whole `handle` block's result. Whether it CAN be that
// result is settled in inference, where the semantic types still exist
@@ -917,9 +804,7 @@ fn emit_resuming_arm_fn(cg: &mut Codegen, arm: &HandlerArm, spec: &ArmFnSpec<'_>
(LType::Ptr, String::from("__coro")),
];
bind_arm_params(cg, arm, spec.sig, spec.resolved, &mut params);
- let op_ret_ty = spec
- .resolved
- .map_or(spec.sig.ret, |r| crate::types::ltype_of(&r.ret));
+ let op_ret_ty = spec.resolved.map_or(spec.sig.ret, |r| ltype_of(&r.ret));
let op_ret_result_inner = spec
.resolved
.and_then(|r| result_inner(&r.ret))
@@ -1109,12 +994,7 @@ pub(crate) fn gen_resume(cg: &mut Codegen, value: Option<&Expr>) -> Result Result {
+ let inferred = match expr {
+ Expr::Integer(_) => Some(osprey_types::Type::con(
+ osprey_types::names::INT,
+ Vec::new(),
+ )),
+ Expr::Float(_) => Some(osprey_types::Type::con(
+ osprey_types::names::FLOAT,
+ Vec::new(),
+ )),
+ Expr::Bool(_) => Some(osprey_types::Type::con(
+ osprey_types::names::BOOL,
+ Vec::new(),
+ )),
+ Expr::Str(_) | Expr::InterpolatedStr(_) => Some(osprey_types::Type::con(
+ osprey_types::names::STRING,
+ Vec::new(),
+ )),
+ Expr::Call { function, .. } => cg.callee_fn_type(function).and_then(|ty| match ty {
+ osprey_types::Type::Fun { ret, .. } => Some(*ret),
+ _ => None,
+ }),
+ Expr::List(_, position) => cg
+ .prog
+ .list_elem_type(*position)
+ .cloned()
+ .map(|element| osprey_types::Type::con(osprey_types::names::LIST, vec![element])),
+ Expr::Perform { position, .. } => position
+ .and_then(|p| cg.prog.performs.get(&(p.line, p.column)))
+ .map(|site| site.op.ret.clone()),
+ _ => None,
+ };
+ let mut value = gen_expr_raw(cg, expr)?;
+ if let Some(ty) = inferred.filter(|ty| !osprey_types::has_type_var(ty)) {
+ value.inferred_type = Some(ty);
+ }
+ Ok(value)
+}
+
+fn gen_expr_raw(cg: &mut Codegen, expr: &Expr) -> Result {
match expr {
Expr::Integer(n) => Ok(Value::new(n.to_string(), LType::I64)),
Expr::Float(f) => Ok(Value::new(fmt_double(*f), LType::Double)),
@@ -48,6 +87,9 @@ pub(crate) fn gen_expr(cg: &mut Codegen, expr: &Expr) -> Result {
None => Err(CodegenError::unknown(name)),
},
},
+ Expr::TypeApply {
+ function, position, ..
+ } => with_application(cg, *position, |cg| gen_expr(cg, function)),
Expr::Binary { op, left, right } => gen_binary(cg, op, left, right),
Expr::Unary { op, operand } => gen_unary(cg, op, operand),
Expr::Call {
@@ -55,6 +97,12 @@ pub(crate) fn gen_expr(cg: &mut Codegen, expr: &Expr) -> Result {
arguments,
named_arguments,
} => gen_call(cg, function, arguments, named_arguments),
+ Expr::MethodCall {
+ target,
+ method,
+ arguments,
+ named_arguments,
+ } => gen_method_call(cg, target, method, arguments, named_arguments),
Expr::Match { value, arms } => gen_match(cg, value, arms),
Expr::Block { statements, value } => gen_block(cg, statements, value.as_deref()),
Expr::TypeConstructor { name, fields, .. } => {
@@ -800,12 +848,96 @@ const BUILTIN_DISPATCH: [BuiltinDispatch; 8] = [
crate::extern_call::gen,
];
+pub(crate) fn unapplied(mut expression: &Expr) -> &Expr {
+ while let Expr::TypeApply { function, .. } = expression {
+ expression = function;
+ }
+ expression
+}
+
+pub(crate) fn with_application(
+ cg: &mut Codegen,
+ position: Option,
+ generate: impl FnOnce(&mut Codegen) -> R,
+) -> R {
+ let bindings = position
+ .and_then(|p| cg.prog.applications.get(&(p.line, p.column)))
+ .cloned();
+ let original = bindings.map(|b| {
+ let specialized = cg.prog.specialized(&b);
+ std::mem::replace(&mut cg.prog, specialized)
+ });
+ let result = generate(cg);
+ if let Some(original) = original {
+ cg.prog = original;
+ }
+ result
+}
+
+/// Deferred generic dotted calls select against the instantiated receiver.
+/// Binding its value before selecting also guarantees exactly one evaluation.
+fn gen_method_call(
+ cg: &mut Codegen,
+ target: &Expr,
+ method: &str,
+ arguments: &[Expr],
+ named: &[NamedArgument],
+) -> Result {
+ let receiver = gen_expr(cg, target)?;
+ let source = osprey_ast::symbol::demangle(method).unwrap_or_else(|| method.to_owned());
+ let field = source.rsplit("::").next().unwrap_or(&source);
+ let has_field = receiver
+ .inferred_type
+ .as_ref()
+ .and_then(|ty| cg.prog.field_type(ty, field))
+ .is_some()
+ || receiver
+ .osp_ty
+ .as_ref()
+ .and_then(|owner| cg.prog.ctors.get(owner))
+ .is_some_and(|ctor| ctor.fields.iter().any(|(name, _)| name == field));
+ let temporary = osprey_ast::generated_name("method_receiver", 0);
+ if !has_field
+ && !cg.fn_params.contains_key(method)
+ && !cg.prog.functions.contains_key(method)
+ && !cg.call_aliases.contains_key(method)
+ && !cg.module_globals.contains_key(method)
+ && cg.lambda_def(method).is_none()
+ && cg.lookup(method).is_none()
+ && osprey_types::builtin_signature(method).is_none()
+ {
+ return Err(CodegenError::unsupported("method call"));
+ }
+ let target = Expr::Identifier(temporary.clone());
+ let mut arguments = arguments.to_vec();
+ let function = if has_field {
+ Expr::FieldAccess {
+ target: Box::new(target),
+ field: field.to_owned(),
+ }
+ } else {
+ arguments.insert(0, target);
+ Expr::Identifier(method.to_owned())
+ };
+ cg.push_scope();
+ cg.bind(temporary, receiver);
+ let result = gen_call(cg, &function, &arguments, named);
+ cg.pop_scope();
+ result
+}
+
fn gen_call(
cg: &mut Codegen,
function: &Expr,
arguments: &[Expr],
named: &[NamedArgument],
) -> Result {
+ if let Expr::TypeApply {
+ function, position, ..
+ } = function
+ {
+ return with_application(cg, *position, |cg| gen_call(cg, function, arguments, named));
+ }
// A directly-applied lambda (`x |> fn(y) => …`, `(fn(y) => …)(x)`) is
// beta-reduced inline.
if let Expr::Lambda {
@@ -815,7 +947,8 @@ fn gen_call(
..
} = function
{
- return apply_lambda(cg, parameters, body, *position, arguments);
+ let slots = arg_exprs(arguments, named);
+ return apply_lambda(cg, parameters, body, *position, &slots);
}
// `applyCurried g 3 4` — the callee is an application spine headed by a
// GENERIC user function, whose intermediate lambdas exist only inside an
@@ -827,36 +960,29 @@ fn gen_call(
}
// `makeAdder(5)(3)` — the callee is itself a call producing a function
// value: evaluate it to a closure handle and call through the cell.
- if let Expr::Call {
- function: inner, ..
- } = function
- {
- if let Expr::Identifier(f) = &**inner {
- let sig = cg
- .call_result_fn_type(f)
- .as_ref()
- .and_then(|t| Codegen::fn_value_sig(&cg.prog, t));
- if let Some(sig) = sig {
- return call_fn_value(cg, function, &sig, arguments, named);
- }
- }
+ if let Some(sig) = call_result_sig(cg, function) {
+ return call_fn_value(cg, function, Some(&sig), arguments, named);
}
let Expr::Identifier(ident) = function else {
// A higher-order callee that is an arbitrary expression — a chained
// application (`add3(1)(2)(3)`) or a function held in a record field.
// Recover its signature from the type table and dispatch through the
// closure cell; fail loudly only when the callee is not a function value.
- if let Some(sig) = cg
+ let sig = cg
.callee_fn_type(function)
.as_ref()
- .and_then(|t| Codegen::fn_value_sig(&cg.prog, t))
- {
- return call_fn_value(cg, function, &sig, arguments, named);
- }
- return Err(CodegenError::unsupported("indirect / higher-order call"));
+ .and_then(|t| Codegen::fn_value_sig(&cg.prog, t));
+ return call_fn_value(cg, function, sig.as_ref(), arguments, named);
};
// A function-valued parameter (bound while inlining a generic function)
// redirects to its real callee, so `f(x)` becomes `toString(x)` / `addOne(x)`.
+ // The source call still targets a value: preserve its written slots before
+ // the known declaration's named-argument path can reorder them.
+ // Implements [CALL-ARGUMENTS].
+ let aliased_arguments = alias_slot_arguments(cg, ident, arguments, named);
+ let (arguments, named) = aliased_arguments
+ .as_deref()
+ .map_or((arguments, named), |arguments| (arguments, &[]));
let name: String = cg
.call_aliases
.get(ident)
@@ -872,7 +998,8 @@ fn gen_call(
}
// A let-bound lambda with no materialized cell is inlined at its call site.
if let Some((params, body, position)) = cg.lambda_def(name).cloned() {
- return apply_bound_lambda(cg, name, ¶ms, &body, position, arguments);
+ let slots = arg_exprs(arguments, named);
+ return apply_bound_lambda(cg, name, ¶ms, &body, position, &slots);
}
match name {
"print" => {
@@ -902,8 +1029,8 @@ fn gen_call(
let arg = first_arg(arguments, named)
.ok_or_else(|| CodegenError::invalid("toFloat needs one argument"))?;
let v = gen_expr(cg, arg)?;
- let n = crate::conv::as_i64(cg, v)?;
- crate::conv::as_double(cg, n)
+ let n = as_i64(cg, v)?;
+ as_double(cg, n)
}
// Compatibility names for the same checked integer operations used by
// the natural operators.
@@ -930,19 +1057,76 @@ fn gen_call(
}
}
+/// Normalize a value call before an inlining alias exposes a declaration's
+/// formal parameter names. The implicit UFCS receiver stays before its values.
+fn alias_slot_arguments(
+ cg: &Codegen,
+ name: &str,
+ arguments: &[Expr],
+ named: &[NamedArgument],
+) -> Option> {
+ (!named.is_empty() && cg.call_aliases.contains_key(name)).then(|| {
+ arguments
+ .iter()
+ .chain(named.iter().map(|argument| &argument.value))
+ .cloned()
+ .collect()
+ })
+}
+
+fn call_result_sig(cg: &Codegen, function: &Expr) -> Option {
+ let Expr::Call {
+ function: inner, ..
+ } = function
+ else {
+ return None;
+ };
+ let Expr::Identifier(name) = &**inner else {
+ return None;
+ };
+ cg.call_result_fn_type(name)
+ .as_ref()
+ .and_then(|ty| Codegen::fn_value_sig(&cg.prog, ty))
+}
+
/// Call through an evaluated function value: lower the callee expression to a
/// closure handle, coerce the arguments to the signature's parameter types,
/// and call through the cell.
fn call_fn_value(
cg: &mut Codegen,
callee: &Expr,
- sig: &FnSig,
+ sig: Option<&FnSig>,
arguments: &[Expr],
named: &[NamedArgument],
) -> Result {
let handle = gen_expr(cg, callee)?;
+ // Generic constructor layouts retain erased field templates. The loaded
+ // closure carries its instantiated type, including float returns and the
+ // function types of callback parameters.
+ let semantic = handle.inferred_type.as_ref();
+ let actual = semantic.and_then(|ty| Codegen::fn_value_sig(&cg.prog, ty));
+ let sig = actual
+ .as_ref()
+ .or(sig)
+ .ok_or_else(|| CodegenError::unsupported("indirect / higher-order call"))?;
+ let slots: Vec<_> = match semantic {
+ Some(osprey_types::Type::Fun { params, .. }) => params
+ .iter()
+ .map(|ty| Codegen::fn_value_sig(&cg.prog, ty))
+ .collect(),
+ _ => Vec::new(),
+ };
let exprs = arg_exprs(arguments, named);
- crate::closure::cell_call_exprs(cg, &handle.operand, sig, &exprs)
+ let values = exprs
+ .iter()
+ .enumerate()
+ .map(|(i, expr)| eval_arg(cg, expr, slots.get(i).and_then(Option::as_ref), false))
+ .collect::>>()?;
+ let mut result = crate::closure::cell_call_values(cg, &handle.operand, sig, values)?;
+ if let Some(osprey_types::Type::Fun { ret, .. }) = semantic {
+ result.inferred_type = Some((**ret).clone());
+ }
+ Ok(result)
}
/// Beta-reduce a lambda at its application site: bind each parameter to its
@@ -961,8 +1145,8 @@ fn apply_bound_lambda(
name: &str,
params: &[Parameter],
body: &Expr,
- position: Option,
- arguments: &[Expr],
+ position: Option,
+ arguments: &[&Expr],
) -> Result {
let Some((prefix_params, prefix_values)) = cg.lambda_prefix.get(name).cloned() else {
return apply_lambda(cg, params, body, position, arguments);
@@ -981,8 +1165,8 @@ fn apply_lambda(
cg: &mut Codegen,
parameters: &[Parameter],
body: &Expr,
- position: Option,
- arguments: &[Expr],
+ position: Option,
+ arguments: &[&Expr],
) -> Result {
let mut values = Vec::with_capacity(arguments.len());
for a in arguments {
@@ -1007,7 +1191,7 @@ fn apply_lambda(
/// int slot, and the second call printed a pointer as a number. A generic
/// lambda is specialised by its ARGUMENTS at each call site instead, exactly as
/// a generic function is ([`crate::genfn`], [TYPE-GENERICS-FN]).
-pub(crate) fn inline_sig(cg: &Codegen, position: Option) -> Option {
+pub(crate) fn inline_sig(cg: &Codegen, position: Option) -> Option {
cg.prog
.lambda_type(position)
.filter(|t| crate::types::fn_value_concrete(t))
@@ -1022,7 +1206,7 @@ pub(crate) fn apply_lambda_values(
body: &Expr,
values: Vec,
sig: Option<&FnSig>,
- position: Option,
+ position: Option,
) -> Result {
reduce_lambda(cg, parameters, body, values, sig, &[], position)
}
@@ -1038,7 +1222,7 @@ pub(crate) fn reduce_lambda(
values: Vec,
sig: Option<&FnSig>,
rest: &[crate::curry::ArgGroup<'_>],
- position: Option,
+ position: Option,
) -> Result {
cg.push_scope();
// `fn_ptr_locals` is per-FUNCTION, not per-scope ([`Codegen::begin_function`]),
@@ -1066,7 +1250,7 @@ fn bind_lambda_params(
parameters: &[Parameter],
values: Vec,
sig: Option<&FnSig>,
- position: Option,
+ position: Option,
) -> Result<()> {
let declared = cg.prog.lambda_type(position).cloned();
for (index, (p, v)) in parameters.iter().zip(values).enumerate() {
@@ -1154,7 +1338,7 @@ fn call_builtin_with_values(cg: &mut Codegen, name: &str, args: &[Value]) -> Opt
"toString" => to_string_value(cg, arg()),
// [BUILTIN-TOFLOAT] [GPU-CONVERT] the canonical float-pipeline seed
// `gpuIota(n) |> gpuMap(toFloat)` lowers through this arm.
- "toFloat" => as_i64(cg, arg()).and_then(|n| crate::conv::as_double(cg, n)),
+ "toFloat" => as_i64(cg, arg()).and_then(|n| as_double(cg, n)),
"abs" => gen_unary_propagating(cg, arg(), gen_abs_value),
_ => return None,
})
@@ -1249,23 +1433,35 @@ fn ordered_args(
.unwrap_or_default();
let ffi = !cg.fn_params.contains_key(name) && cg.prog.functions.contains_key(name);
if !named.is_empty() {
- if let Some(pnames) = cg.fn_params.get(name).cloned() {
+ if let Some(pnames) = cg
+ .fn_params
+ .get(name)
+ .or_else(|| cg.extern_params.get(name))
+ .cloned()
+ {
let mut out = Vec::new();
for (i, pn) in pnames.iter().enumerate() {
- if let Some(na) = named.iter().find(|a| &a.name == pn) {
+ if let Some(argument) = arguments
+ .get(i)
+ .or_else(|| named.iter().find(|a| &a.name == pn).map(|a| &a.value))
+ {
out.push(eval_arg(
cg,
- &na.value,
+ argument,
sigs.get(i).and_then(Option::as_ref),
ffi,
)?);
}
}
- if out.len() == named.len() {
+ if out.len() == arguments.len() + named.len() {
return Ok(out);
}
}
- return named.iter().map(|na| gen_expr(cg, &na.value)).collect();
+ return arguments
+ .iter()
+ .chain(named.iter().map(|na| &na.value))
+ .map(|argument| gen_expr(cg, argument))
+ .collect();
}
arguments
.iter()
@@ -1281,6 +1477,12 @@ fn ordered_args(
/// Everything else goes through `gen_expr` (where a user function name becomes
/// its forwarder cell).
fn eval_arg(cg: &mut Codegen, expr: &Expr, sig: Option<&FnSig>, ffi: bool) -> Result {
+ if let Expr::TypeApply {
+ function, position, ..
+ } = expr
+ {
+ return with_application(cg, *position, |cg| eval_arg(cg, function, sig, ffi));
+ }
match (expr, sig) {
(
Expr::Lambda {
diff --git a/crates/osprey-codegen/src/extern_call.rs b/crates/osprey-codegen/src/extern_call.rs
index b34abc97..c23875d7 100644
--- a/crates/osprey-codegen/src/extern_call.rs
+++ b/crates/osprey-codegen/src/extern_call.rs
@@ -141,21 +141,34 @@ fn eval_args(
.zip(crate::expr::arg_exprs(args, named))
.enumerate()
.map(|(index, (want, e))| {
- let v = match e {
- Expr::Identifier(n)
- if *want == LType::Ptr
- && cg.lookup(n).is_none()
- && cg.fn_params.contains_key(n) =>
- {
- callback_pointer(cg, n, name, index)?
- }
- _ => gen_expr(cg, e)?,
- };
+ let v = argument_value(cg, e, *want, name, index)?;
Ok(crate::cast::coerce_to(cg, v, *want)?.operand)
})
.collect()
}
+fn argument_value(
+ cg: &mut Codegen,
+ expr: &Expr,
+ want: LType,
+ name: &str,
+ index: usize,
+) -> Result {
+ match expr {
+ Expr::TypeApply {
+ function, position, ..
+ } => crate::expr::with_application(cg, *position, |cg| {
+ argument_value(cg, function, want, name, index)
+ }),
+ Expr::Identifier(n)
+ if want == LType::Ptr && cg.lookup(n).is_none() && cg.fn_params.contains_key(n) =>
+ {
+ callback_pointer(cg, n, name, index)
+ }
+ _ => gen_expr(cg, expr),
+ }
+}
+
/// The raw code pointer for a callback argument. A handler whose types are
/// INFERRED is generic and has no `@name` symbol of its own, so pointing at one
/// emitted IR that references a body codegen never defined — reported as
diff --git a/crates/osprey-codegen/src/fiber.rs b/crates/osprey-codegen/src/fiber.rs
index 34929cc5..93e1cf02 100644
--- a/crates/osprey-codegen/src/fiber.rs
+++ b/crates/osprey-codegen/src/fiber.rs
@@ -57,6 +57,9 @@ pub(crate) fn gen_spawn(cg: &mut Codegen, e: &Expr) -> Result {
/// can tag the handle for `await` to unbox.
fn thunk_body(cg: &mut Codegen, e: &Expr) -> Result {
let v = gen_expr(cg, e)?;
+ // Await restores the runtime list ABI, so materialize an inlined generic
+ // call's literal result before its pointer crosses the fiber boundary.
+ let v = crate::listlit::escaping(cg, v);
let elem = v.clone();
// The result escapes boxed across the fiber boundary: dup it before the
// thunk's owners drop, so the runtime's completed-result slot holds +1
@@ -119,7 +122,7 @@ pub(crate) fn gen_send(cg: &mut Codegen, channel: &Expr, value: &Expr) -> Result
let id = as_i64(cg, ch)?;
let v = gen_expr(cg, value)?;
if v.result_inner.is_some() {
- return Err(crate::error::CodegenError::unsupported(
+ return Err(CodegenError::unsupported(
"Result-valued channels are not yet represented losslessly; handle the Result before sending",
));
}
@@ -238,9 +241,7 @@ pub(crate) fn gen_builtin(cg: &mut Codegen, name: &str, args: &[Expr]) -> Result
// [CONCURRENCY-YIELD].
"fiberDone" => {
let Some(a) = args.first() else {
- return Err(crate::error::CodegenError::invalid(
- "fiberDone needs a fiber argument",
- ));
+ return Err(CodegenError::invalid("fiberDone needs a fiber argument"));
};
let v = gen_expr(cg, a)?;
let id = as_i64(cg, v)?;
diff --git a/crates/osprey-codegen/src/genfn.rs b/crates/osprey-codegen/src/genfn.rs
index 95eddec1..0f7c0afe 100644
--- a/crates/osprey-codegen/src/genfn.rs
+++ b/crates/osprey-codegen/src/genfn.rs
@@ -222,11 +222,11 @@ fn pair_args<'a>(
} else {
params
.iter()
- .filter_map(|p| {
- named
- .iter()
- .find(|n| n.name == p.name)
- .map(|n| (p, &n.value))
+ .enumerate()
+ .filter_map(|(index, p)| {
+ args.get(index)
+ .or_else(|| named.iter().find(|n| n.name == p.name).map(|n| &n.value))
+ .map(|argument| (p, argument))
})
.collect()
}
diff --git a/crates/osprey-codegen/src/gpu.rs b/crates/osprey-codegen/src/gpu.rs
index 4c434644..b254ac32 100644
--- a/crates/osprey-codegen/src/gpu.rs
+++ b/crates/osprey-codegen/src/gpu.rs
@@ -186,8 +186,7 @@ fn buffer_literal(
/// buffer sized at the *source* length, because the kept count is not known
/// until the loop has run.
fn kept_counter(cg: &mut Codegen) -> String {
- let kept = cg.fresh_reg();
- cg.emit(format!("{kept} = alloca i64"));
+ let kept = cg.emit_reg("alloca i64");
cg.emit(format!("store i64 0, i64* {kept}"));
kept
}
diff --git a/crates/osprey-codegen/src/gpu_kernel.rs b/crates/osprey-codegen/src/gpu_kernel.rs
index 6db048ec..af315636 100644
--- a/crates/osprey-codegen/src/gpu_kernel.rs
+++ b/crates/osprey-codegen/src/gpu_kernel.rs
@@ -275,6 +275,7 @@ fn param_sigs(parameters: &[Parameter], own: Option<&FnSig>, slots: &[LType]) ->
ty: slots.get(i).copied().unwrap_or(LType::I64),
result_inner: None,
fiber: None,
+ inferred_type: None,
},
})
.collect()
@@ -332,6 +333,7 @@ fn bind_uniforms(cg: &mut Codegen, caps: &[crate::closure::Capture]) -> Vec<(LTy
ty: c.val.ty,
result_inner: None,
fiber: None,
+ inferred_type: c.val.inferred_type.clone(),
};
// `incoming_param` registers no ownership: a uniform buffer handle is
// BORROWED for the call's duration, exactly as a top-level function's
@@ -386,7 +388,7 @@ mod tests {
/// The parsed mode, or the rendered error — assertable without requiring
/// `PartialEq` on the codegen error type.
- fn parsed(value: Option<&str>) -> std::result::Result {
+ fn parsed(value: Option<&str>) -> Result {
mode_of(value).map_err(|e| e.to_string())
}
diff --git a/crates/osprey-codegen/src/iter.rs b/crates/osprey-codegen/src/iter.rs
index 4e5305be..fad8b62a 100644
--- a/crates/osprey-codegen/src/iter.rs
+++ b/crates/osprey-codegen/src/iter.rs
@@ -186,8 +186,7 @@ fn branch_on_predicate(cg: &mut Codegen, cb: &Callback, elem: Value) -> Result<(
let pred = invoke(cg, cb, vec![elem])?;
let pred = crate::cast::coerce_to(cg, pred, LType::I1)?;
let pb = as_i64(cg, pred)?;
- let nz = cg.fresh_reg();
- cg.emit(format!("{nz} = icmp ne i64 {}, 0", pb.operand));
+ let nz = cg.emit_reg(format!("icmp ne i64 {}, 0", pb.operand));
let taken = cg.fresh_label();
let rejected = cg.fresh_label();
cg.emit(format!("br i1 {nz}, label %{taken}, label %{rejected}"));
@@ -258,8 +257,7 @@ pub(crate) fn acc_init(cg: &mut Codegen, args: &[Expr]) -> Result<(String, Value
crate::arc::escape_retain(cg, &initial);
let tmpl = initial.clone();
let boxed = box_to_i64(cg, initial);
- let acc = cg.fresh_reg();
- cg.emit(format!("{acc} = alloca i64"));
+ let acc = cg.emit_reg("alloca i64");
cg.emit(format!("store i64 {}, i64* {acc}", boxed.operand));
Ok((acc, tmpl))
}
@@ -409,7 +407,7 @@ fn list_builder(cg: &mut Codegen, args: &[Expr], filter: bool) -> Result
}
let mapped = invoke(cg, &f, vec![elem])?;
if mapped.result_inner.is_some() {
- return Err(crate::error::CodegenError::unsupported(
+ return Err(CodegenError::unsupported(
"mapList cannot store an unhandled Result element; handle it in the callback",
));
}
diff --git a/crates/osprey-codegen/src/lib.rs b/crates/osprey-codegen/src/lib.rs
index 0871c1f9..45cb7149 100644
--- a/crates/osprey-codegen/src/lib.rs
+++ b/crates/osprey-codegen/src/lib.rs
@@ -50,6 +50,9 @@ mod runtime;
mod stmt;
mod strings;
mod testing;
+#[cfg(test)]
+#[path = "../../testkit.rs"]
+mod testkit;
mod types;
pub use error::{CodegenError, Result};
@@ -98,6 +101,7 @@ fn stmt_idents(s: &osprey_ast::Stmt, out: &mut std::collections::BTreeSet String {
@@ -162,10 +166,15 @@ mod tests {
#[test]
fn emits_main_and_puts_for_hello() {
let ir = module("print(\"hello\")\n");
- assert!(ir.contains("define i32 @main() #0"));
- assert!(ir.contains("declare i32 @puts(i8*)"));
- assert!(ir.contains("call i32 @puts"));
- assert!(ir.contains("hello\\00"));
+ shows(
+ &ir,
+ &[
+ "define i32 @main() #0",
+ "declare i32 @puts(i8*)",
+ "call i32 @puts",
+ "hello\\00",
+ ],
+ );
// Every function keeps frame pointers so the sampling profiler's
// FP-chain walk is valid from any pc [PROF-CODEGEN-FP].
assert!(ir.contains("attributes #0 = { \"frame-pointer\"=\"all\" }"));
@@ -196,11 +205,16 @@ mod tests {
#[test]
fn testing_builtins_lower_to_tap_runtime_calls() {
let ir = module("test(\"adds\", fn() => expect(1 + 1, 2))\n");
- assert!(ir.contains("call i32 @osp_test_begin(i8*"));
- assert!(ir.contains("call void @osp_test_end(i8*"));
- assert!(ir.contains("call void @osp_test_assert(i8* null, i32"));
- assert!(ir.contains("call i32 @osp_test_finalize()"));
- assert!(ir.contains("call i32 @strcmp(i8*"));
+ shows(
+ &ir,
+ &[
+ "call i32 @osp_test_begin(i8*",
+ "call void @osp_test_end(i8*",
+ "call void @osp_test_assert(i8* null, i32",
+ "call i32 @osp_test_finalize()",
+ "call i32 @strcmp(i8*",
+ ],
+ );
}
#[test]
@@ -269,8 +283,10 @@ mod tests {
// [TESTING-EQUALITY] a Result operand branches on its discriminant:
// Success renders bare, Error renders as Error().
let ir = module("expect(intDiv(1, 0), 2)\n");
- assert!(ir.contains("call void @osp_test_assert(i8* null, i32"));
- assert!(ir.contains("Error(%s)"));
+ shows(
+ &ir,
+ &["call void @osp_test_assert(i8* null, i32", "Error(%s)"],
+ );
// A list/map/record operand has no canonical rendering — loud error.
assert!(compile_err("expect([1, 2], [1, 3])\n")
.to_string()
@@ -308,23 +324,33 @@ mod tests {
);
let expected_dwarf_version = if cfg!(target_os = "macos") { 4 } else { 5 };
- assert!(ir.contains("source_filename = \"/tmp/debug.osp\""));
- assert!(ir.contains("!llvm.dbg.cu = !{!"));
- assert!(ir.contains("!llvm.module.flags = !{!"));
- assert!(ir.contains("!DICompileUnit("));
- assert!(ir.contains("!DIFile(filename: \"debug.osp\", directory: \"/tmp\")"));
- assert!(ir.contains(&format!("!\"Dwarf Version\", i32 {expected_dwarf_version}")));
- assert!(ir.contains("!DISubprogram(name: \"add\""));
- assert!(ir.contains("!DISubprogram(name: \"main\""));
- assert!(ir.contains("!DILocalVariable(name: \"x\""));
+ shows(
+ &ir,
+ &[
+ "source_filename = \"/tmp/debug.osp\"",
+ "!llvm.dbg.cu = !{!",
+ "!llvm.module.flags = !{!",
+ "!DICompileUnit(",
+ "!DIFile(filename: \"debug.osp\", directory: \"/tmp\")",
+ &format!("!\"Dwarf Version\", i32 {expected_dwarf_version}"),
+ "!DISubprogram(name: \"add\"",
+ "!DISubprogram(name: \"main\"",
+ "!DILocalVariable(name: \"x\"",
+ ],
+ );
// Parameters (a, b) use dbg.value — SSA args live for the whole
// function. `let` locals (x) use dbg.declare over a stack slot, the
// robust -O0 representation that keeps the line table free of stray
// line-0 rows. [DEBUGGER-DBG-DECLARE]
- assert!(ir.contains("@llvm.dbg.value"));
- assert!(ir.contains("call void @llvm.dbg.declare(metadata"));
- assert!(ir.contains("!DILocation(line: 2, column: 1"));
- assert!(ir.contains(", !dbg !"));
+ shows(
+ &ir,
+ &[
+ "@llvm.dbg.value",
+ "call void @llvm.dbg.declare(metadata",
+ "!DILocation(line: 2, column: 1",
+ ", !dbg !",
+ ],
+ );
}
#[test]
@@ -466,9 +492,14 @@ mod tests {
let r = apply(value: 10, f: fn(x: int) => (x + 1) ?: x)\n\
print(\"r=${r}\")\n",
);
- assert!(ir.contains("define i64 @__closure_fn_0(i8* %__env, i64 %$p0)"));
- assert!(ir.contains("@__closure_cell_0 = private unnamed_addr constant { i8* }"));
- assert!(ir.contains("call i64 %"));
+ shows(
+ &ir,
+ &[
+ "define i64 @__closure_fn_0(i8* %__env, i64 %$p0)",
+ "@__closure_cell_0 = private unnamed_addr constant { i8* }",
+ "call i64 %",
+ ],
+ );
}
#[test]
@@ -484,16 +515,20 @@ mod tests {
print(\"r=${add5(3)}\")\n\
}\n",
);
- assert!(ir.contains("define i8* @makeAdder(i64 %$p0)"));
- assert!(ir.contains("bitcast i8* %__env to { i8*, i64 }*"));
- assert!(ir.contains("call i8* @osp_alloc"));
+ shows(
+ &ir,
+ &[
+ "define i8* @makeAdder(i64 %$p0)",
+ "bitcast i8* %__env to { i8*, i64 }*",
+ "call i8* @osp_alloc",
+ ],
+ );
}
#[test]
fn interpolation_uses_sprintf() {
let ir = module("let x = 7\nprint(\"x=${x}\")\n");
- assert!(ir.contains("@sprintf"));
- assert!(ir.contains("@osp_alloc"));
+ shows(&ir, &["@sprintf", "@osp_alloc"]);
}
/// An erasure builds a shape-carrying box, and ownership crosses it in
@@ -613,9 +648,7 @@ mod tests {
#[test]
fn match_lowers_to_phi() {
let ir = module("fn pick(a: int, b: int) -> int = match a < b { true => a false => b }\n");
- assert!(ir.contains("icmp"));
- assert!(ir.contains("br i1"));
- assert!(ir.contains("phi i64"));
+ shows(&ir, &["icmp", "br i1", "phi i64"]);
}
#[test]
@@ -625,6 +658,15 @@ mod tests {
// return type is `{ i64, i8 }*`; what matters here is the argument order.
let ir = module("fn sub(a, b) = a - b\nlet r = sub(b: 1, a: 9)\n");
assert!(ir.contains("@sub(i64 9, i64 1)"));
+ let external = module(
+ "extern fn takeFirst(first: int, second: int) -> int\n\
+ fn namedWitness() -> int = takeFirst(second: 22, first: 11)\n",
+ );
+ assert!(
+ function_body(&external, "define i64 @namedWitness()")
+ .contains("@takeFirst(i64 11, i64 22)"),
+ "extern calls must preserve declaration order and the C ABI:\n{external}"
+ );
}
#[test]
@@ -687,9 +729,7 @@ mod tests {
print(\"sum=${s}\")\n\
}\n",
);
- assert!(ir.contains("@osp_alloc"));
- assert!(ir.contains("icmp ne i64"));
- assert!(ir.contains("alloca i64"));
+ shows(&ir, &["@osp_alloc", "icmp ne i64", "alloca i64"]);
}
#[test]
@@ -710,9 +750,14 @@ mod tests {
print(\"len=${listLength(m)} f=${listLength(f)} t=${t}\")\n\
}\n",
);
- assert!(ir.contains("osprey_list_builder_new"));
- assert!(ir.contains("osprey_list_builder_push"));
- assert!(ir.contains("osprey_list_builder_seal"));
+ shows(
+ &ir,
+ &[
+ "osprey_list_builder_new",
+ "osprey_list_builder_push",
+ "osprey_list_builder_seal",
+ ],
+ );
}
#[test]
@@ -756,8 +801,7 @@ mod tests {
print(\"r=${g()}\")\n\
}\n",
);
- assert!(ir.contains("call i8* @osp_alloc"));
- assert!(ir.contains("bitcast i8* %__env"));
+ shows(&ir, &["call i8* @osp_alloc", "bitcast i8* %__env"]);
}
#[test]
@@ -813,8 +857,7 @@ mod tests {
}\n\
fn main() -> Unit = print(\"a=${area(Circle { r: 3 })}\")\n",
);
- assert!(ir.contains("load i64, i64*"));
- assert!(ir.contains("icmp eq i64"));
+ shows(&ir, &["load i64, i64*", "icmp eq i64"]);
assert_eq!(
ir.matches("call { i64, i1 } @llvm.smul.with.overflow.i64")
.count(),
@@ -921,8 +964,7 @@ mod tests {
print(\"r=${first(V { a: 10, b: 20 })}\")\n",
);
// The field bind loads slot 1 of the block, reached via the tag compare.
- assert!(ir.contains("load i64, i64*"));
- assert!(ir.contains("icmp eq i64"));
+ shows(&ir, &["load i64, i64*", "icmp eq i64"]);
}
#[test]
@@ -942,10 +984,15 @@ mod tests {
print(classify(xs))\n\
}\n",
);
- assert!(ir.contains("osprey_list_length"));
- assert!(ir.contains("osprey_list_get"));
- assert!(ir.contains("osprey_list_drop"));
- assert!(ir.contains("icmp sge i64"));
+ shows(
+ &ir,
+ &[
+ "osprey_list_length",
+ "osprey_list_get",
+ "osprey_list_drop",
+ "icmp sge i64",
+ ],
+ );
}
#[test]
@@ -1012,9 +1059,14 @@ mod tests {
let wrapped = choose(7)\n\
print(\"${failed}:${wrapped}\")\n",
);
- assert!(closure.contains("define i64 @__closure_fn_"));
- assert!(closure.contains("i8* %__env, i8* %$p0"));
- assert!(closure.contains("bitcast i8* %$p0 to { i64, i8, i8* }*"));
+ shows(
+ &closure,
+ &[
+ "define i64 @__closure_fn_",
+ "i8* %__env, i8* %$p0",
+ "bitcast i8* %$p0 to { i64, i8, i8* }*",
+ ],
+ );
}
/// Matching a bare scalar against `Success`/`Error` arms takes the Success
@@ -1106,11 +1158,16 @@ mod tests {
print(\"${join(ws, \"-\")} ${listLength(ls)}\")\n\
}\n",
);
- assert!(ir.contains("@osp_strlen"));
- assert!(ir.contains("osp_string_to_upper"));
- assert!(ir.contains("osp_parse_int_strict"));
- assert!(ir.contains("osp_string_codepoint_at"));
- assert!(ir.contains("osp_string_join"));
+ shows(
+ &ir,
+ &[
+ "@osp_strlen",
+ "osp_string_to_upper",
+ "osp_parse_int_strict",
+ "osp_string_codepoint_at",
+ "osp_string_join",
+ ],
+ );
}
// ---- collections: map literals, map operations ----
@@ -1131,10 +1188,15 @@ mod tests {
match m[\"a\"] { Success { value } => print(\"i=${value}\") Error { message } => print(\"no\") }\n\
}\n",
);
- assert!(ir.contains("osprey_map_builder_new"));
- assert!(ir.contains("osprey_map_set"));
- assert!(ir.contains("osprey_map_remove"));
- assert!(ir.contains("osprey_map_iter_new"));
+ shows(
+ &ir,
+ &[
+ "osprey_map_builder_new",
+ "osprey_map_set",
+ "osprey_map_remove",
+ "osprey_map_iter_new",
+ ],
+ );
}
#[test]
@@ -1250,8 +1312,7 @@ mod tests {
match listGet(xs, 0) { Success { value } => print(\"v=${value}\") Error { message } => print(\"no\") }\n\
}\n",
);
- assert!(ir.contains("osprey_list_in_bounds"));
- assert!(ir.contains("@strcmp"));
+ shows(&ir, &["osprey_list_in_bounds", "@strcmp"]);
}
// ---- algebraic effects: handler-owned state (effects.rs) ----
@@ -1392,8 +1453,13 @@ mod tests {
fn main() -> int { mut c = 0\n let r = handle State get => c set v => { c = v } in bump()\n print(\"r=${toString(r)} c=${toString(c)}\")\n 0 }\n",
);
// env-carrying handler ABI (push takes a 4th i8* env; perform resolves it)
- assert!(ir.contains("declare i32 @__osprey_handler_push(i8*, i8*, i8*, i8*)"));
- assert!(ir.contains("@__osprey_handler_lookup_env"));
+ shows(
+ &ir,
+ &[
+ "declare i32 @__osprey_handler_push(i8*, i8*, i8*, i8*)",
+ "@__osprey_handler_lookup_env",
+ ],
+ );
// the captured `mut` became a heap cell (malloc'd, stored, loaded)
assert!(ir.contains("@osp_alloc"));
// each arm is emitted with the hidden leading env parameter
@@ -1437,8 +1503,7 @@ mod tests {
"fn greet(n: string) -> string = \"hi ${n}\"\n\
fn main() -> Unit = print(await(spawn greet(\"x\")))\n",
);
- assert!(ir.contains("fiber_await"));
- assert!(ir.contains("inttoptr i64"));
+ shows(&ir, &["fiber_await", "inttoptr i64"]);
assert!(
ir.lines()
.any(|line| line.contains("@fiber_spawn_env_owned") && line.ends_with(", i64 1)")),
@@ -1507,10 +1572,7 @@ mod tests {
print(\"${mixed} ${q} ${neg} ${negi} ${lt} ${m}\")\n\
}\n",
);
- assert!(ir.contains("sitofp i64"));
- assert!(ir.contains("fdiv double"));
- assert!(ir.contains("fneg double"));
- assert!(ir.contains("fcmp"));
+ shows(&ir, &["sitofp i64", "fdiv double", "fneg double", "fcmp"]);
}
#[test]
@@ -1526,9 +1588,7 @@ mod tests {
print(\"${c} ${d} ${e}\")\n\
}\n",
);
- assert!(ir.contains("and i1"));
- assert!(ir.contains("or i1"));
- assert!(ir.contains("xor i1"));
+ shows(&ir, &["and i1", "or i1", "xor i1"]);
}
// ---- records / aggregate (aggregate.rs) ----
@@ -1545,8 +1605,7 @@ mod tests {
print(\"${p.x} ${p.y} ${p2.x}\")\n\
}\n",
);
- assert!(ir.contains("getelementptr"));
- assert!(ir.contains("store i64"));
+ shows(&ir, &["getelementptr", "store i64"]);
}
#[test]
@@ -1584,10 +1643,15 @@ card doc index selected =
print(\"${got} ${y} ${z} ${await(f)} ${fiberDone(f)}\")\n\
}\n",
);
- assert!(ir.contains("channel_create"));
- assert!(ir.contains("channel_send"));
- assert!(ir.contains("channel_recv"));
- assert!(ir.contains("fiber_done"));
+ shows(
+ &ir,
+ &[
+ "channel_create",
+ "channel_send",
+ "channel_recv",
+ "fiber_done",
+ ],
+ );
}
#[test]
@@ -1639,6 +1703,16 @@ card doc index selected =
// from the type table and dispatch through the closure cell.
let ir = module(
"type Cfg = { keep: (int) -> bool }\n\
+ type Dispatch = Dispatch { m: () -> string }\n\
+ fn methodField() -> string = \"field\"\n\
+ fn m(receiver: T) -> int = 31\n\
+ fn dispatch(receiver: T) = receiver.m()\n\
+ fn echo(receiver: T) -> T = receiver\n\
+ fn deferEcho(receiver: T) = receiver.echo()\n\
+ fn explicitWitness() -> int = 5.echo()\n\
+ fn deferredWitness() -> int = deferEcho(7)\n\
+ fn fallbackWitness() -> int = dispatch(9)\n\
+ fn fieldWitness() -> string = dispatch(Dispatch { m: methodField })\n\
fn add3(a: int) -> (int) -> (int) -> int =\n\
fn(b: int) => fn(c: int) => (a + b + c) ?: a\n\
fn makeAdder(n: int) -> (int) -> int = fn(x: int) => (x + n) ?: x\n\
@@ -1647,11 +1721,86 @@ card doc index selected =
let chain = add3(1)(2)(3)\n\
let computed = fold(map(range(1, 4), makeAdder(10)), 0, fn(a: int, b: int) => (a + b) ?: a)\n\
let fieldcb = fold(filter(range(1, 5), cfg.keep), 0, fn(a: int, b: int) => (a + b) ?: a)\n\
- print(\"${chain} ${computed} ${fieldcb}\")\n\
+ print(\"${chain} ${computed} ${fieldcb} ${explicitWitness()} ${deferredWitness()} ${fallbackWitness()} ${fieldWitness()}\")\n\
}\n",
);
// Each higher-order callee loads a function pointer from a closure cell.
assert!(ir.contains("to { i8* }*"), "expected a closure cell-call");
+ for (name, value) in [
+ ("explicitWitness", 5),
+ ("deferredWitness", 7),
+ ("fallbackWitness", 31),
+ ] {
+ assert!(
+ function_body(&ir, &format!("define i64 @{name}()"))
+ .contains(&format!("ret i64 {value}")),
+ "{name} must return its selected generic function's value:\n{ir}"
+ );
+ }
+ assert!(
+ function_body(&ir, "define i8* @fieldWitness()").contains("call i8* %"),
+ "the callable record field must retain its string-returning ABI:\n{ir}"
+ );
+
+ // A field callback returns another callable through two generic helpers.
+ // The second record also proves named field arguments keep written slots.
+ let returned = module(
+ "effect Probe { value: fn() -> int }\n\
+ fn fetch() -> int !Probe = perform Probe.value()\n\
+ fn pure() -> int = 22\n\
+ type Factory = Factory { m: () -> () -> int }\n\
+ type NamedFactory = NamedFactory { m: (() -> int, () -> int) -> () -> int }\n\
+ fn pureFactory() -> () -> int = pure\n\
+ fn effectFactory() -> () -> int = fetch\n\
+ fn firstCallback(callback: () -> int, ignored: () -> int) -> () -> int = callback\n\
+ fn secondCallback(callback: () -> int, ignored: () -> int) -> () -> int = ignored\n\
+ fn m(x: T) -> () -> int = pure\n\
+ fn dispatch(x: T) = x.m()\n\
+ fn dispatchNamed(x: T) = x.m(ignored: pure, callback: fetch)\n\
+ fn forward(dummy: T, cb: () -> () -> int) = dispatch(Factory { m: cb })()\n\
+ fn forwardNamed(dummy: T, cb: (() -> int, () -> int) -> () -> int) = dispatchNamed(NamedFactory { m: cb })()\n\
+ fn firstSlot(first: int, second: int) -> int = first\n\
+ fn throughSlot(dummy: T, callback: (int, int) -> int) = callback(second: 22, first: 11)\n\
+ fn genericSlotWitness() -> int = throughSlot(0, firstSlot)\n\
+ fn declaredSlotWitness() -> int = firstSlot(second: 22, first: 11)\n\
+ fn directLambdaWitness() -> int = (fn(first: int, second: int) => first)(second: 22, first: 11)\n\
+ fn throughLambda(unused: T) = (fn(first: int, second: int) => first)(second: 22, first: 11)\n\
+ fn genericLambdaWitness() -> int = throughLambda(0)\n\
+ fn pureWitness() -> int = forward(0, pureFactory)\n\
+ fn namedPureWitness() -> int = forwardNamed(0, firstCallback)\n\
+ fn handledWitness() -> int = handle Probe value => 33 in forward(0, effectFactory)\n\
+ fn namedHandledWitness() -> int = handle Probe value => 33 in forwardNamed(0, secondCallback)\n\
+ print(\"${pureWitness()} ${namedPureWitness()} ${handledWitness()} ${namedHandledWitness()} ${genericSlotWitness()} ${declaredSlotWitness()} ${directLambdaWitness()} ${genericLambdaWitness()}\")\n",
+ );
+ for witness in ["pureWitness", "namedPureWitness"] {
+ let body = function_body(&returned, &format!("define i64 @{witness}()"));
+ assert!(
+ body.contains("call i8* %") && body.contains("call i64 %"),
+ "{witness} must call the factory and then its returned int callback:\n{returned}"
+ );
+ }
+ assert!(
+ returned.contains("@__osprey_handler_push")
+ && returned.contains("@__osprey_handler_lookup_env"),
+ "returned effectful callbacks must retain their dynamic handler:\n{returned}"
+ );
+ for (witness, arguments) in [
+ ("genericSlotWitness", "i64 22, i64 11"),
+ ("declaredSlotWitness", "i64 11, i64 22"),
+ ] {
+ assert!(
+ function_body(&returned, &format!("define i64 @{witness}()"))
+ .contains(&format!("@firstSlot({arguments})")),
+ "{witness} must preserve its source call site's argument slots:\n{returned}"
+ );
+ }
+ for witness in ["directLambdaWitness", "genericLambdaWitness"] {
+ assert!(
+ function_body(&returned, &format!("define i64 @{witness}()"))
+ .contains("ret i64 22"),
+ "{witness} must bind named values in written slots:\n{returned}"
+ );
+ }
}
#[test]
@@ -1784,8 +1933,7 @@ card doc index selected =
print(\"${listLength(fs)} ${listLength(bs)}\")\n\
}\n",
);
- assert!(ir.contains("bitcast double"));
- assert!(ir.contains("zext i1"));
+ shows(&ir, &["bitcast double", "zext i1"]);
}
#[test]
@@ -1799,8 +1947,7 @@ card doc index selected =
print(\"${a == b}\")\n\
}\n",
);
- assert!(ir.contains("zext i1"));
- assert!(ir.contains("icmp eq i64"));
+ shows(&ir, &["zext i1", "icmp eq i64"]);
}
#[test]
@@ -1814,8 +1961,7 @@ card doc index selected =
print(\"${gt}\")\n\
}\n",
);
- assert!(ir.contains("sitofp i64"));
- assert!(ir.contains("fcmp"));
+ shows(&ir, &["sitofp i64", "fcmp"]);
}
#[test]
@@ -1856,8 +2002,8 @@ card doc index selected =
fn codegen_constructors_are_callable_directly() {
// builder.rs Codegen::new + Default (not used by compile_program, which
// takes inferred types) — exercised directly for the public surface.
- let _a = crate::builder::Codegen::new();
- let _b = crate::builder::Codegen::default();
+ let _a = builder::Codegen::new();
+ let _b = builder::Codegen::default();
}
// ---- GPU kernel extraction [GPU-KERNEL-EXTRACT] ----
@@ -1904,8 +2050,13 @@ card doc index selected =
print(f())\n",
);
assert_eq!(ir.matches(KERNEL_PREFIX).count(), 4, "{ir}");
- assert!(ir.contains("define double @__gpu_kernel_0(double %$p0)"));
- assert!(ir.contains("define double @__gpu_kernel_1(double %$p0)"));
+ shows(
+ &ir,
+ &[
+ "define double @__gpu_kernel_0(double %$p0)",
+ "define double @__gpu_kernel_1(double %$p0)",
+ ],
+ );
}
#[test]
@@ -1925,8 +2076,7 @@ card doc index selected =
let header = "define double @__gpu_kernel_0(double %$p0, double %$p1, double %$p2)";
assert!(ir.contains(header), "{ir}");
let kernel = function_body(&ir, header);
- assert!(kernel.contains("fmul double %$p1, %$p2"), "{kernel}");
- assert!(kernel.contains("fadd double"), "{kernel}");
+ shows(&kernel, &["fmul double %$p1, %$p2", "fadd double"]);
assert!(!kernel.contains("__env"), "{kernel}");
let host = function_body(&ir, "define i64 @f()");
assert!(
@@ -1963,8 +2113,7 @@ card doc index selected =
let header = "define double @__gpu_kernel_0(double %$p0, double %$p1, double %$p2)";
assert!(ir.contains(header), "{ir}");
let kernel = function_body(&ir, header);
- assert!(kernel.contains("fmul double %$p0, %$p2"), "{kernel}");
- assert!(kernel.contains("fadd double %$p1,"), "{kernel}");
+ shows(&kernel, &["fmul double %$p0, %$p2", "fadd double %$p1,"]);
}
/// A handler with one RESUMING arm and one SUBSTITUTING arm continues by
diff --git a/crates/osprey-codegen/src/listlit.rs b/crates/osprey-codegen/src/listlit.rs
index eaf7f5e2..35f293cc 100644
--- a/crates/osprey-codegen/src/listlit.rs
+++ b/crates/osprey-codegen/src/listlit.rs
@@ -143,16 +143,14 @@ pub(crate) fn gen_list(
let elem_owner = first.osp_ty.clone();
let n = elements.len();
let data = cg.heap_alloc(&(n * 8).to_string());
- let arr = cg.fresh_reg();
- cg.emit(format!("{arr} = bitcast i8* {data} to {}*", elem.as_str()));
+ let arr = cg.emit_reg(format!("bitcast i8* {data} to {}*", elem.as_str()));
for (i, v) in vals.into_iter().enumerate() {
let v = coerce_to(cg, v, elem)?;
// The header's drop releases pointer elements, so each store is a new
// reference [GC-ARC-PERCEUS].
crate::arc::dup_store(cg, elem.as_str(), &v.operand);
- let slot = cg.fresh_reg();
- cg.emit(format!(
- "{slot} = getelementptr {}, {}* {arr}, i64 {i}",
+ let slot = cg.emit_reg(format!(
+ "getelementptr {}, {}* {arr}, i64 {i}",
elem.as_str(),
elem.as_str()
));
@@ -259,7 +257,7 @@ pub(crate) fn gen_index(cg: &mut Codegen, target: &Expr, index: &Expr) -> Result
.as_deref()
.is_some_and(crate::collections::is_map_owner)
{
- let key = crate::cast::coerce_to(cg, iv, LType::Str)?;
+ let key = coerce_to(cg, iv, LType::Str)?;
let k = crate::conv::box_to_i64(cg, key);
return crate::collections::runtime_map_get(cg, &tv, &k);
}
@@ -285,36 +283,23 @@ pub(crate) fn gen_index(cg: &mut Codegen, target: &Expr, index: &Expr) -> Result
let data = crate::aggregate::load_field(cg, LIST_STRUCT, &tv.operand, 1, LType::Str);
// bounds: 0 <= idx < length
- let ge0 = cg.fresh_reg();
- cg.emit(format!("{ge0} = icmp sge i64 {}, 0", idx.operand));
- let lt = cg.fresh_reg();
- cg.emit(format!("{lt} = icmp slt i64 {}, {len}", idx.operand));
- let ok = cg.fresh_reg();
- cg.emit(format!("{ok} = and i1 {ge0}, {lt}"));
+ let ge0 = cg.emit_reg(format!("icmp sge i64 {}, 0", idx.operand));
+ let lt = cg.emit_reg(format!("icmp slt i64 {}, {len}", idx.operand));
+ let ok = cg.emit_reg(format!("and i1 {ge0}, {lt}"));
// Load only on the in-bounds path — the OOB / empty (`data == null`) path
// must not dereference.
- let load_bb = cg.fresh_label();
- let oob_bb = cg.fresh_label();
- let cont = cg.fresh_label();
- cg.emit(format!("br i1 {ok}, label %{load_bb}, label %{oob_bb}"));
+ let (load_bb, oob_bb, cont) = cg.diamond(&ok);
cg.start_block(&load_bb);
- let arr = cg.fresh_reg();
- cg.emit(format!("{arr} = bitcast i8* {data} to {}*", elem.as_str()));
- let slot = cg.fresh_reg();
- cg.emit(format!(
- "{slot} = getelementptr {}, {}* {arr}, i64 {}",
+ let arr = cg.emit_reg(format!("bitcast i8* {data} to {}*", elem.as_str()));
+ let slot = cg.emit_reg(format!(
+ "getelementptr {}, {}* {arr}, i64 {}",
elem.as_str(),
elem.as_str(),
idx.operand
));
- let val = cg.fresh_reg();
- cg.emit(format!(
- "{val} = load {}, {}* {slot}",
- elem.as_str(),
- elem.as_str()
- ));
+ let val = cg.emit_reg(format!("load {}, {}* {slot}", elem.as_str(), elem.as_str()));
cg.emit(format!("br label %{cont}"));
cg.start_block(&oob_bb);
@@ -322,13 +307,11 @@ pub(crate) fn gen_index(cg: &mut Codegen, target: &Expr, index: &Expr) -> Result
cg.start_block(&cont);
let zero = crate::llty::zero_literal(elem);
- let phi = cg.fresh_reg();
- cg.emit(format!(
- "{phi} = phi {} [ {val}, %{load_bb} ], [ {zero}, %{oob_bb} ]",
+ let phi = cg.emit_reg(format!(
+ "phi {} [ {val}, %{load_bb} ], [ {zero}, %{oob_bb} ]",
elem.as_str()
));
- let disc = cg.fresh_reg();
- cg.emit(format!("{disc} = select i1 {ok}, i8 0, i8 1"));
+ let disc = cg.emit_reg(format!("select i1 {ok}, i8 0, i8 1"));
// `ok` is the in-bounds flag, so the message is selected on the failing path.
let oob = cg.string_constant(crate::collections::INDEX_OOB);
let errmsg = cg.emit_reg(format!("select i1 {ok}, i8* null, i8* {}", oob.operand));
diff --git a/crates/osprey-codegen/src/llty.rs b/crates/osprey-codegen/src/llty.rs
index 1a903e6e..32811264 100644
--- a/crates/osprey-codegen/src/llty.rs
+++ b/crates/osprey-codegen/src/llty.rs
@@ -196,7 +196,7 @@ impl fmt::Display for LType {
/// (`null` when Success or when the producer set no message). The single source
/// of truth for the Result ABI layout — every builder/reader spells it via here.
#[must_use]
-pub fn result_struct_ty(inner: LType) -> String {
+pub(crate) fn result_struct_ty(inner: LType) -> String {
format!("{{ {inner}, i8, i8* }}")
}
@@ -227,6 +227,8 @@ pub struct Value {
/// (`Point`, `Shape`, `Result`, …) so field access and `match` can recover
/// the heap layout. `None` for scalars and untyped handles.
pub(crate) osp_ty: Option,
+ /// The semantic type survives equal-layout generic record instantiations.
+ pub(crate) inferred_type: Option,
/// When `Some(inner)`, this value is a `Result` carried as a
/// pointer to a heap block `{ inner, i8 disc }` (disc 0 = Success). Match,
/// `?:`, failure-preserving arithmetic, and Result rendering read this to
@@ -264,6 +266,7 @@ impl Value {
operand: operand.into(),
ty,
osp_ty: None,
+ inferred_type: None,
result_inner: None,
result_inner_is_placeholder: false,
payload_owner: None,
@@ -280,6 +283,7 @@ impl Value {
operand: operand.into(),
ty: LType::Ptr,
osp_ty: Some(owner.into()),
+ inferred_type: None,
result_inner: None,
result_inner_is_placeholder: false,
payload_owner: None,
@@ -297,6 +301,7 @@ impl Value {
operand: operand.into(),
ty: LType::Ptr,
osp_ty: Some("Result".to_string()),
+ inferred_type: None,
result_inner: Some(inner),
result_inner_is_placeholder: false,
payload_owner: None,
diff --git a/crates/osprey-codegen/src/loops.rs b/crates/osprey-codegen/src/loops.rs
index f131c418..87d288cd 100644
--- a/crates/osprey-codegen/src/loops.rs
+++ b/crates/osprey-codegen/src/loops.rs
@@ -21,8 +21,7 @@ pub(crate) struct Counter {
}
fn open_counter(cg: &mut Codegen, start: &str, bound: &str) -> Counter {
- let slot = cg.fresh_reg();
- cg.emit(format!("{slot} = alloca i64"));
+ let slot = cg.emit_reg("alloca i64");
cg.emit(format!("store i64 {start}, i64* {slot}"));
let cond = cg.fresh_label();
let body = cg.fresh_label();
@@ -31,10 +30,8 @@ fn open_counter(cg: &mut Codegen, start: &str, bound: &str) -> Counter {
cg.emit(format!("br label %{cond}"));
cg.start_block(&cond);
- let i = cg.fresh_reg();
- cg.emit(format!("{i} = load i64, i64* {slot}"));
- let more = cg.fresh_reg();
- cg.emit(format!("{more} = icmp slt i64 {i}, {bound}"));
+ let i = cg.emit_reg(format!("load i64, i64* {slot}"));
+ let more = cg.emit_reg(format!("icmp slt i64 {i}, {bound}"));
cg.emit(format!("br i1 {more}, label %{body}, label %{endl}"));
cg.start_block(&body);
diff --git a/crates/osprey-codegen/src/lower.rs b/crates/osprey-codegen/src/lower.rs
index 08a2ceda..164fd0f1 100644
--- a/crates/osprey-codegen/src/lower.rs
+++ b/crates/osprey-codegen/src/lower.rs
@@ -80,7 +80,9 @@ fn compile_program_with_options(program: &Program, options: CodegenOptions) -> R
fn compile_module(program: &Program, options: CodegenOptions, library: bool) -> Result {
let options = with_kernel_mode(options)?;
- let prog = osprey_types::infer_program(program);
+ let mut prog = osprey_types::infer_program(program);
+ let elaborated = prog.elaborate_calls(program);
+ let program = &elaborated;
let mut cg = Codegen::with_options(prog, options);
// Seed the coverage denominator from the source, not from what lowering
// happens to reach [TESTING-COVERAGE-CODEGEN].
@@ -234,9 +236,20 @@ fn record_declarations(cg: &mut Codegen, program: &Program) {
// A union an extern claims to return loses its MASK_DIRECT proof
// (builder.rs `field_meta`); record those before any layout lands.
Stmt::Extern {
- return_type: Some(t),
+ name,
+ parameters,
+ return_type,
..
- } => cg.poison_extern_ret(t),
+ } => {
+ // Implements [CALL-ARGUMENTS] without changing foreign ABI identity.
+ let _ = cg.extern_params.insert(
+ name.clone(),
+ parameters.iter().map(|p| p.name.clone()).collect(),
+ );
+ if let Some(t) = return_type {
+ cg.poison_extern_ret(t);
+ }
+ }
_ => {}
}
}
@@ -277,6 +290,7 @@ fn gen_function(
ty: LType::I64,
result_inner: None,
fiber: None,
+ inferred_type: None,
},
None,
);
@@ -305,7 +319,12 @@ fn gen_function(
let mut params = Vec::new();
for (i, (p, (pty, owner))) in parameters.iter().zip(param_sig.iter()).enumerate() {
let reg = crate::llty::param_register(i);
- let v = crate::cast::incoming_param(cg, format!("%{reg}"), pty.clone(), owner.clone());
+ let mut v = crate::cast::incoming_param(cg, format!("%{reg}"), pty.clone(), owner.clone());
+ v.inferred_type = cg
+ .prog
+ .param_types(name)
+ .and_then(|types| types.get(i))
+ .cloned();
cg.emit_debug_param(&p.name, &v);
cg.bind(p.name.clone(), v);
params.push((pty.ty, reg));
diff --git a/crates/osprey-codegen/src/monofn.rs b/crates/osprey-codegen/src/monofn.rs
index f31d1bab..bc1db4e0 100644
--- a/crates/osprey-codegen/src/monofn.rs
+++ b/crates/osprey-codegen/src/monofn.rs
@@ -237,6 +237,7 @@ fn param_of(v: &Value) -> ParamSig {
ty: v.ty,
result_inner: v.result_inner,
fiber: None,
+ inferred_type: v.inferred_type.clone(),
}
}
@@ -256,6 +257,9 @@ fn bind_params(
// the call's duration, exactly as a top-level function's are
// [GC-ARC-PERCEUS].
let value = crate::cast::incoming_param(cg, format!("%{reg}"), sig.clone(), owner.clone());
+ if let Some(ty) = &value.inferred_type {
+ cg.bind_fn_local(&p.name, ty.clone());
+ }
cg.bind(p.name.clone(), value);
out.push((sig.ty, reg));
}
diff --git a/crates/osprey-codegen/src/pattern.rs b/crates/osprey-codegen/src/pattern.rs
index ec633aff..a67b7cf7 100644
--- a/crates/osprey-codegen/src/pattern.rs
+++ b/crates/osprey-codegen/src/pattern.rs
@@ -380,8 +380,7 @@ fn gen_result_match(cg: &mut Codegen, disc: &Value, arms: &[MatchArm]) -> Result
// (cond, success-binding, error-binding) by Result shape.
let (cond, succ_val, err_val) = if disc.result_inner.is_some() {
let d = crate::result::load_disc(cg, disc);
- let c = cg.fresh_reg();
- cg.emit(format!("{c} = icmp eq i8 {d}, 0"));
+ let c = cg.emit_reg(format!("icmp eq i8 {d}, 0"));
// Success binds the value slot; Error binds the errmsg slot (the real
// reason), so `Error { message }` sees the message regardless of the
// success payload type. Implements [ERR-PAYLOAD].
@@ -420,10 +419,7 @@ fn gen_result_match(cg: &mut Codegen, disc: &Value, arms: &[MatchArm]) -> Result
("true".to_string(), disc.clone(), empty)
};
- let sl = cg.fresh_label();
- let el = cg.fresh_label();
- let end = cg.fresh_label();
- cg.emit(format!("br i1 {cond}, label %{sl}, label %{el}"));
+ let (sl, el, end) = cg.diamond(&cond);
let mark = crate::arc::frame_mark(cg);
let mut phi_in: Vec<(Value, String)> = Vec::new();
@@ -467,10 +463,8 @@ fn gen_union_match(
owner: &str,
) -> Result {
// Load the discriminant tag (every variant block starts with `{ i64 tag, … }`).
- let tagp = cg.fresh_reg();
- cg.emit(format!("{tagp} = bitcast i8* {} to i64*", disc.operand));
- let tag = cg.fresh_reg();
- cg.emit(format!("{tag} = load i64, i64* {tagp}"));
+ let tagp = cg.emit_reg(format!("bitcast i8* {} to i64*", disc.operand));
+ let tag = cg.emit_reg(format!("load i64, i64* {tagp}"));
let end = cg.fresh_label();
let mark = crate::arc::frame_mark(cg);
@@ -482,8 +476,7 @@ fn gen_union_match(
let name = name.to_string();
let vpos = variants.iter().position(|v| *v == name).unwrap_or(0);
let vtag = i64::try_from(vpos).unwrap_or(0);
- let cond = cg.fresh_reg();
- cg.emit(format!("{cond} = icmp eq i64 {tag}, {vtag}"));
+ let cond = cg.emit_reg(format!("icmp eq i64 {tag}, {vtag}"));
let next_lbl = open_guarded_arm(cg, &cond);
bind_variant_fields(cg, disc, &name, &fields, mode);
emit_arm_body(cg, arm, &mut phi_in)?;
@@ -555,11 +548,7 @@ fn bind_variant_fields(
let Some((view, struct_ty)) = bindable_layout(cg, variant, pat_fields) else {
return;
};
- let src = cg.fresh_reg();
- cg.emit(format!(
- "{src} = bitcast i8* {} to {struct_ty}*",
- disc.operand
- ));
+ let src = cg.emit_reg(format!("bitcast i8* {} to {struct_ty}*", disc.operand));
for (column, bind_name) in pat_fields.iter().enumerate() {
if bind_name.is_empty() {
continue; // an ignored slot binds nothing
@@ -709,8 +698,7 @@ fn finish_phi(
.map(|(v, blk)| format!("[ {}, %{blk} ]", v.operand))
.collect::>()
.join(", ");
- let reg = cg.fresh_reg();
- cg.emit(format!("{reg} = phi {llvm_ty} {incoming}"));
+ let reg = cg.emit_reg(format!("phi {llvm_ty} {incoming}"));
let common = |sel: fn(&Value) -> Option| {
let first = sel(first_val);
incoming_values
diff --git a/crates/osprey-codegen/src/result.rs b/crates/osprey-codegen/src/result.rs
index a0d2ae75..af14e764 100644
--- a/crates/osprey-codegen/src/result.rs
+++ b/crates/osprey-codegen/src/result.rs
@@ -39,14 +39,12 @@ pub(crate) fn make_result(
]);
let obj = cg.malloc_struct(&struct_ty, meta);
crate::aggregate::store_field(cg, &struct_ty, obj.as_str(), 0, inner, &v.operand);
- let dp = cg.fresh_reg();
- cg.emit(format!(
- "{dp} = getelementptr {struct_ty}, {struct_ty}* {obj}, i32 0, i32 1"
+ let dp = cg.emit_reg(format!(
+ "getelementptr {struct_ty}, {struct_ty}* {obj}, i32 0, i32 1"
));
cg.emit(format!("store i8 {disc}, i8* {dp}"));
- let mp = cg.fresh_reg();
- cg.emit(format!(
- "{mp} = getelementptr {struct_ty}, {struct_ty}* {obj}, i32 0, i32 2"
+ let mp = cg.emit_reg(format!(
+ "getelementptr {struct_ty}, {struct_ty}* {obj}, i32 0, i32 2"
));
// The block's drop mask releases the errmsg word too [GC-ARC-PERCEUS].
crate::arc::dup_store(cg, "i8*", errmsg);
@@ -100,8 +98,7 @@ pub(crate) fn make_result_if_err_because(
msg: Option<&str>,
reason: Option<&str>,
) -> Result {
- let disc = cg.fresh_reg();
- cg.emit(format!("{disc} = select i1 {is_err}, i8 1, i8 0"));
+ let disc = cg.emit_reg(format!("select i1 {is_err}, i8 1, i8 0"));
let fallback = match msg {
Some(m) => cg.string_constant(m).operand,
None => NO_MSG.to_string(),
@@ -173,10 +170,7 @@ pub(crate) fn result_from_nullable(
pub(crate) fn open_result_branch(cg: &mut Codegen, v: &Value) -> (String, String, String) {
let d = load_disc(cg, v);
let is_succ = cg.emit_reg(format!("icmp eq i8 {d}, 0"));
- let sl = cg.fresh_label();
- let el = cg.fresh_label();
- let end = cg.fresh_label();
- cg.emit(format!("br i1 {is_succ}, label %{sl}, label %{el}"));
+ let (sl, el, end) = cg.diamond(&is_succ);
cg.start_block(&sl);
(sl, el, end)
}
@@ -188,13 +182,11 @@ pub(crate) fn load_disc(cg: &mut Codegen, v: &Value) -> String {
let Some(struct_ty) = v.result_struct_ty() else {
return "1".to_string();
};
- let dp = cg.fresh_reg();
- cg.emit(format!(
- "{dp} = getelementptr {struct_ty}, {struct_ty}* {}, i32 0, i32 1",
+ let dp = cg.emit_reg(format!(
+ "getelementptr {struct_ty}, {struct_ty}* {}, i32 0, i32 1",
v.operand
));
- let d = cg.fresh_reg();
- cg.emit(format!("{d} = load i8, i8* {dp}"));
+ let d = cg.emit_reg(format!("load i8, i8* {dp}"));
d
}
@@ -217,13 +209,11 @@ pub(crate) fn load_errmsg(cg: &mut Codegen, v: &Value) -> Value {
return Value::new(NO_MSG, LType::Str);
};
let struct_ty = result_struct_ty(inner);
- let mp = cg.fresh_reg();
- cg.emit(format!(
- "{mp} = getelementptr {struct_ty}, {struct_ty}* {}, i32 0, i32 2",
+ let mp = cg.emit_reg(format!(
+ "getelementptr {struct_ty}, {struct_ty}* {}, i32 0, i32 2",
v.operand
));
- let raw = cg.fresh_reg();
- cg.emit(format!("{raw} = load i8*, i8** {mp}"));
+ let raw = cg.emit_reg(format!("load i8*, i8** {mp}"));
Value::new(raw, LType::Str)
}
@@ -256,12 +246,7 @@ pub(crate) fn repack_to_inner(cg: &mut Codegen, v: Value, inner: LType) -> Resul
let disc = load_disc(cg, &v);
let errmsg = load_errmsg(cg, &v);
let is_success = cg.emit_reg(format!("icmp eq i8 {disc}, 0"));
- let success = cg.fresh_label();
- let error = cg.fresh_label();
- let end = cg.fresh_label();
- cg.emit(format!(
- "br i1 {is_success}, label %{success}, label %{error}"
- ));
+ let (success, error, end) = cg.diamond(&is_success);
cg.start_block(&success);
let loaded = load_value(cg, &v);
diff --git a/crates/osprey-codegen/src/runtime.rs b/crates/osprey-codegen/src/runtime.rs
index 0a68d7ba..d18f2778 100644
--- a/crates/osprey-codegen/src/runtime.rs
+++ b/crates/osprey-codegen/src/runtime.rs
@@ -61,10 +61,7 @@ fn result_string(cg: &mut Codegen, v: &Value, wrap_success: bool) -> Result)`.
let msg = crate::result::load_errmsg(cg, v);
let isnull = cg.emit_reg(format!("icmp eq i8* {}, null", msg.operand));
- let fl = cg.fresh_label();
- let nl = cg.fresh_label();
- let jl = cg.fresh_label();
- cg.emit(format!("br i1 {isnull}, label %{nl}, label %{fl}"));
+ let (nl, fl, jl) = cg.diamond(&isnull);
cg.start_block(&fl);
let with = sprintf_wrap(cg, "Error(%s)", &msg.operand);
let fb = cg.cur_block().to_string();
@@ -73,18 +70,14 @@ fn result_string(cg: &mut Codegen, v: &Value, wrap_success: bool) -> Result Valu
pub(crate) fn gen_print(cg: &mut Codegen, v: Value) -> Result {
let s = to_string_value(cg, v)?;
cg.add_extern("declare i32 @puts(i8*)");
- let reg = cg.fresh_reg();
- cg.emit(format!("{reg} = call i32 @puts(i8* {})", s.operand));
+ let _ = cg.emit_reg(format!("call i32 @puts(i8* {})", s.operand));
Ok(Value::unit())
}
@@ -157,9 +149,8 @@ fn int_to_string(cg: &mut Codegen, v: Value) -> Result {
// full i64 on every target; on LP64 (native) it is identical to `%ld`.
let fmt = cg.string_constant("%lld");
let buf = cg.heap_alloc(INT_STRING_BYTES);
- let tmp = cg.fresh_reg();
- cg.emit(format!(
- "{tmp} = call i32 (i8*, i8*, ...) @sprintf(i8* {buf}, i8* {}, i64 {})",
+ let _ = cg.emit_reg(format!(
+ "call i32 (i8*, i8*, ...) @sprintf(i8* {buf}, i8* {}, i64 {})",
fmt.operand, i.operand
));
let v = Value::new(buf, LType::Str);
@@ -171,9 +162,8 @@ fn int_to_string(cg: &mut Codegen, v: Value) -> Result {
/// that (and NaN/inf) — see `runtime/string_runtime.c`.
fn float_to_string(cg: &mut Codegen, v: &Value) -> Value {
cg.add_extern("declare i8* @osp_float_to_string(double)");
- let reg = cg.fresh_reg();
- cg.emit(format!(
- "{reg} = call i8* @osp_float_to_string(double {})",
+ let reg = cg.emit_reg(format!(
+ "call i8* @osp_float_to_string(double {})",
v.operand
));
let out = Value::new(reg, LType::Str);
@@ -184,9 +174,8 @@ fn float_to_string(cg: &mut Codegen, v: &Value) -> Value {
fn bool_to_string(cg: &mut Codegen, v: &Value) -> Value {
let t = cg.string_constant("true");
let f = cg.string_constant("false");
- let reg = cg.fresh_reg();
- cg.emit(format!(
- "{reg} = select i1 {}, i8* {}, i8* {}",
+ let reg = cg.emit_reg(format!(
+ "select i1 {}, i8* {}, i8* {}",
v.operand, t.operand, f.operand
));
Value::new(reg, LType::Str)
diff --git a/crates/osprey-codegen/src/stmt.rs b/crates/osprey-codegen/src/stmt.rs
index 28044786..a12fa4dd 100644
--- a/crates/osprey-codegen/src/stmt.rs
+++ b/crates/osprey-codegen/src/stmt.rs
@@ -288,7 +288,14 @@ fn gen_bind(cg: &mut Codegen, name: &str, value: &Expr, position: Option …; f = makeAdder(10)` must
// call the new closure, not the old inline body.
@@ -362,7 +369,7 @@ fn generic_returned_lambda(cg: &Codegen, value: &Expr) -> Option
let Expr::Call { function, .. } = value else {
return None;
};
- let Expr::Identifier(callee) = &**function else {
+ let Expr::Identifier(callee) = crate::expr::unapplied(function) else {
return None;
};
// A CONCRETELY-typed result materializes a real cell on the ordinary path,
@@ -401,7 +408,7 @@ fn captures_callee_params(cg: &Codegen, value: &Expr) -> bool {
let Some((callee_params, _, body, _)) = generic_returned_lambda(cg, value) else {
return false;
};
- let mut free = std::collections::BTreeSet::new();
+ let mut free = BTreeSet::new();
osprey_ast::freevars::free_idents(&body, &mut free);
callee_params.iter().any(|p| free.contains(&p.name))
}
@@ -502,6 +509,9 @@ pub(crate) fn binds_no_value(cg: &Codegen, value: &Expr) -> bool {
/// uses it to keep inlined function-typed parameters callable.
pub(crate) fn fn_result_type(cg: &Codegen, value: &Expr) -> Option {
match value {
+ Expr::TypeApply { .. } => cg
+ .callee_fn_type(value)
+ .filter(crate::types::fn_value_concrete),
Expr::Lambda { position, .. } => cg
.prog
.lambda_type(*position)
diff --git a/crates/osprey-codegen/src/strings.rs b/crates/osprey-codegen/src/strings.rs
index 737cd6b3..79456327 100644
--- a/crates/osprey-codegen/src/strings.rs
+++ b/crates/osprey-codegen/src/strings.rs
@@ -145,8 +145,7 @@ pub(crate) fn gen_size(cg: &mut Codegen, name: &str, recv: Value) -> Result = ops.iter().map(String::as_str).collect();
let raw = cg.call("i64", cname, ¶ms, &op_refs);
- let r = cg.fresh_reg();
- cg.emit(format!("{r} = icmp ne i64 {raw}, 0"));
+ let r = cg.emit_reg(format!("icmp ne i64 {raw}, 0"));
Ok(Value::new(r, LType::I1))
}
@@ -242,8 +240,7 @@ fn contains(cg: &mut Codegen, args: &[Expr], _named: &[NamedArgument]) -> Result
let s = arg(cg, args, 0, LType::Str)?;
let needle = arg(cg, args, 1, LType::Str)?;
let hit = cg.call("i8*", "strstr", "i8*, i8*", &[&s.operand, &needle.operand]);
- let r = cg.fresh_reg();
- cg.emit(format!("{r} = icmp ne i8* {hit}, null"));
+ let r = cg.emit_reg(format!("icmp ne i8* {hit}, null"));
Ok(Value::new(r, LType::I1))
}
@@ -257,10 +254,8 @@ fn index_of(cg: &mut Codegen, args: &[Expr], _named: &[NamedArgument]) -> Result
"i8*, i8*",
&[&s.operand, &needle.operand],
);
- let iserr = cg.fresh_reg();
- cg.emit(format!("{iserr} = icmp slt i64 {idx}, 0"));
- let val = cg.fresh_reg();
- cg.emit(format!("{val} = select i1 {iserr}, i64 0, i64 {idx}"));
+ let iserr = cg.emit_reg(format!("icmp slt i64 {idx}, 0"));
+ let val = cg.emit_reg(format!("select i1 {iserr}, i64 0, i64 {idx}"));
make_result_if_err(
cg,
Value::new(val, LType::I64),
@@ -315,8 +310,7 @@ fn parse_strict(
_named: &[NamedArgument],
) -> Result {
let s = arg(cg, args, 0, LType::Str)?;
- let slot = cg.fresh_reg();
- cg.emit(format!("{slot} = alloca {inner}"));
+ let slot = cg.emit_reg(format!("alloca {inner}"));
let zero = crate::llty::zero_literal(inner);
cg.emit(format!("store {inner} {zero}, {inner}* {slot}"));
let rc = cg.call(
@@ -325,10 +319,8 @@ fn parse_strict(
&format!("i8*, {inner}*"),
&[&s.operand, &slot],
);
- let parsed = cg.fresh_reg();
- cg.emit(format!("{parsed} = load {inner}, {inner}* {slot}"));
- let iserr = cg.fresh_reg();
- cg.emit(format!("{iserr} = icmp ne i64 {rc}, 0"));
+ let parsed = cg.emit_reg(format!("load {inner}, {inner}* {slot}"));
+ let iserr = cg.emit_reg(format!("icmp ne i64 {rc}, 0"));
make_result_if_err(cg, Value::new(parsed, inner), inner, &iserr, Some(errmsg))
}
@@ -354,8 +346,7 @@ fn split(cg: &mut Codegen, args: &[Expr]) -> Result {
&[&s.operand, &sep.operand],
);
crate::arc::own(cg, &Value::new(&ptr, LType::Ptr));
- let iserr = cg.fresh_reg();
- cg.emit(format!("{iserr} = icmp eq i8* {ptr}, null"));
+ let iserr = cg.emit_reg(format!("icmp eq i8* {ptr}, null"));
make_result_if_err(
cg,
Value::handle(ptr, crate::listlit::STRING_LIST_OWNER),
@@ -371,19 +362,15 @@ fn split(cg: &mut Codegen, args: &[Expr]) -> Result {
/// errmsg slot. `argtys` lists the leading argument types before the out-slot.
fn cursor_int(cg: &mut Codegen, cname: &str, argtys: &[LType], args: &[Expr]) -> Result {
let (mut ops, params) = typed_args_for_types(cg, argtys, args)?;
- let slot = cg.fresh_reg();
- cg.emit(format!("{slot} = alloca i64"));
+ let slot = cg.emit_reg("alloca i64");
cg.emit(format!("store i64 0, i64* {slot}"));
ops.push(slot.clone());
let full_params = format!("{params}, i64*");
let op_refs: Vec<&str> = ops.iter().map(String::as_str).collect();
let emsg = cg.call("i8*", cname, &full_params, &op_refs);
- let parsed = cg.fresh_reg();
- cg.emit(format!("{parsed} = load i64, i64* {slot}"));
- let is_err = cg.fresh_reg();
- cg.emit(format!("{is_err} = icmp ne i8* {emsg}, null"));
- let disc = cg.fresh_reg();
- cg.emit(format!("{disc} = select i1 {is_err}, i8 1, i8 0"));
+ let parsed = cg.emit_reg(format!("load i64, i64* {slot}"));
+ let is_err = cg.emit_reg(format!("icmp ne i8* {emsg}, null"));
+ let disc = cg.emit_reg(format!("select i1 {is_err}, i8 1, i8 0"));
make_result(cg, Value::new(parsed, LType::I64), LType::I64, &disc, &emsg)
}
diff --git a/crates/osprey-codegen/src/types.rs b/crates/osprey-codegen/src/types.rs
index 85832910..318ee071 100644
--- a/crates/osprey-codegen/src/types.rs
+++ b/crates/osprey-codegen/src/types.rs
@@ -24,7 +24,7 @@ pub(crate) fn elem_tag(prog: &ProgramTypes, elem: Option<&Type>) -> Option LType {
+pub(crate) fn ltype_of(ty: &Type) -> LType {
match ty {
Type::Con { name, args } => ltype_of_con(name, args),
// A function reference is a code pointer; values never hold one directly
@@ -95,8 +95,22 @@ pub(crate) fn result_payload_owner(prog: &ProgramTypes, ty: &Type) -> Option` ([`crate::gpu::GPU_TAG`]), the same convention flat
/// list literals use (`[]double`), so combinator lowering recovers the
/// element's `LType` through parameters and returns [GPU-BUFFER-ELEM].
-pub fn owner_name(prog: &ProgramTypes, ty: &Type) -> Option {
+pub(crate) fn owner_name(prog: &ProgramTypes, ty: &Type) -> Option {
match ty {
+ Type::Record { name, fields }
+ if prog
+ .ctors
+ .get(name)
+ .is_some_and(|layout| !layout.type_params.is_empty()) =>
+ {
+ let layout = prog.ctors.get(name)?;
+ let shape: Option> = layout
+ .fields
+ .iter()
+ .map(|(field, _)| fields.get(field).map(|ty| ltype_of(ty).as_str()))
+ .collect();
+ shape.map(|shape| format!("{name}#{}", shape.join(",")))
+ }
Type::Record { name, .. } | Type::Union { name, .. } => Some(name.clone()),
Type::Con { name, args } => match name.as_str() {
names::INT
@@ -180,7 +194,7 @@ fn substituted(ty: &Type, args: &[Type]) -> Type {
/// "every value of this type is a constructor-built ARC body or NULL" true.
/// A `Result` is its own discriminated block and therefore does not prove
/// that the outer value is a heap value of `T`.
-pub fn proven_heap_name(ty: &Type) -> Option<&str> {
+pub(crate) fn proven_heap_name(ty: &Type) -> Option<&str> {
match ty {
Type::Con { name, .. } if name == names::RESULT => None,
// A declared union or any other named constructor: the name IS the proof.
@@ -191,7 +205,7 @@ pub fn proven_heap_name(ty: &Type) -> Option<&str> {
/// When `ty` is `Result`, the inner success type `T` as an [`LType`].
/// Used to carry the `{ T, i8 }*` Result block across call/return boundaries.
-pub fn result_inner(ty: &Type) -> Option {
+pub(crate) fn result_inner(ty: &Type) -> Option {
match ty {
Type::Con { name, args } if name == names::RESULT => args.first().map(ltype_of),
_ => None,
@@ -200,7 +214,7 @@ pub fn result_inner(ty: &Type) -> Option {
/// Whether a function type yields a concrete closure ABI: every parameter and
/// return are variable-free. Result returns keep their wrapper in the ABI.
-pub fn fn_value_concrete(ty: &Type) -> bool {
+pub(crate) fn fn_value_concrete(ty: &Type) -> bool {
match ty {
Type::Fun { params, ret } => {
!params.iter().any(osprey_types::has_type_var) && !osprey_types::has_type_var(ret)
diff --git a/crates/osprey-lsp/src/analysis.rs b/crates/osprey-lsp/src/analysis.rs
index e9600dde..c9295025 100644
--- a/crates/osprey-lsp/src/analysis.rs
+++ b/crates/osprey-lsp/src/analysis.rs
@@ -5,10 +5,9 @@
//! into editor symbols — both the language server and the `osprey --symbols` /
//! `osprey --hover` CLI modes render from here.
-use osprey_ast::{
- walk_each, Expr, ExternParameter, InterpolatedPart, NamedArgument, Parameter, Position,
- Program, Stmt, TypeExpr,
-};
+#[cfg(test)]
+use osprey_ast::InterpolatedPart;
+use osprey_ast::{AstNode, Expr, ExternParameter, Parameter, Position, Program, Stmt, TypeExpr};
use std::fmt::Write as _;
/// What kind of declaration a [`SymbolInfo`] describes.
@@ -227,139 +226,22 @@ fn walk_stmt_body(stmt: &Stmt, prefix: &[String], out: &mut Vec) {
}
}
-/// Descend an expression collecting nested `let` bindings (first third).
+/// Descend expressions while preserving block-local symbol collection.
fn walk_expr(e: &Expr, prefix: &[String], out: &mut Vec) {
match e {
- Expr::InterpolatedStr(parts) => parts.iter().for_each(|p| {
- if let InterpolatedPart::Expr(x) = p {
- walk_expr(x, prefix, out);
- }
- }),
- Expr::List(xs, _) => walk_each(xs, out, |x| x, |x, out| walk_expr(x, prefix, out)),
- Expr::Map(entries) => entries.iter().for_each(|en| {
- walk_expr(&en.key, prefix, out);
- walk_expr(&en.value, prefix, out);
- }),
- Expr::Object(fields) => walk_each(
- fields,
- out,
- |f| &f.value,
- |x, out| {
- walk_expr(x, prefix, out);
- },
- ),
- Expr::Binary { left, right, .. } | Expr::Pipe { left, right } => {
- walk_expr(left, prefix, out);
- walk_expr(right, prefix, out);
- }
- Expr::Unary { operand, .. } => walk_expr(operand, prefix, out),
- other => walk_expr_rest(other, prefix, out),
- }
-}
-
-/// Continuation of [`walk_expr`] — call/navigation/block forms (second third).
-fn walk_expr_rest(e: &Expr, prefix: &[String], out: &mut Vec) {
- match e {
- Expr::Call {
- function,
- arguments,
- named_arguments,
- } => {
- walk_expr(function, prefix, out);
- walk_arguments(arguments, named_arguments, prefix, out);
- }
- Expr::MethodCall {
- target,
- arguments,
- named_arguments,
- ..
- } => {
- walk_expr(target, prefix, out);
- walk_arguments(arguments, named_arguments, prefix, out);
- }
- Expr::FieldAccess { target, .. } => walk_expr(target, prefix, out),
- Expr::Index { target, index } => {
- walk_expr(target, prefix, out);
- walk_expr(index, prefix, out);
- }
- Expr::Lambda { body, .. } => walk_expr(body, prefix, out),
- Expr::Match { value, arms } => {
- walk_expr(value, prefix, out);
- walk_each(
- arms,
- out,
- |arm| &arm.body,
- |x, out| {
- walk_expr(x, prefix, out);
- },
- );
- }
Expr::Block { statements, value } => {
walk_stmts(statements, prefix, Bodies::Descend, out);
- if let Some(v) = value {
- walk_expr(v, prefix, out);
+ if let Some(value) = value {
+ walk_expr(value, prefix, out);
}
}
- Expr::TypeConstructor { fields, .. } | Expr::Update { fields, .. } => {
- walk_each(
- fields,
- out,
- |f| &f.value,
- |x, out| {
- walk_expr(x, prefix, out);
- },
- );
- }
- other => walk_expr_fiber(other, prefix, out),
- }
-}
-
-/// Final third of [`walk_expr`]: fiber/effect forms; leaves fall through.
-fn walk_expr_fiber(e: &Expr, prefix: &[String], out: &mut Vec) {
- match e {
- Expr::Spawn(i) | Expr::Await(i) | Expr::Recv(i) | Expr::Yield(Some(i)) => {
- walk_expr(i, prefix, out);
- }
- Expr::Send { channel, value } => {
- walk_expr(channel, prefix, out);
- walk_expr(value, prefix, out);
- }
- Expr::Select { arms } => walk_each(
- arms,
- out,
- |arm| &arm.body,
- |x, out| {
- walk_expr(x, prefix, out);
- },
- ),
- Expr::Perform {
- arguments,
- named_arguments,
- ..
- } => {
- walk_arguments(arguments, named_arguments, prefix, out);
- }
- Expr::Handler { arms, body, .. } => {
- for arm in arms {
- walk_expr(&arm.body, prefix, out);
+ // Resume operands were not part of this symbol collector's traversal.
+ Expr::Resume(_) => {}
+ _ => AstNode::Expression(e).for_each_child(|child| {
+ if let AstNode::Expression(expression) = child {
+ walk_expr(expression, prefix, out);
}
- walk_expr(body, prefix, out);
- }
- _ => {}
- }
-}
-
-fn walk_arguments(
- arguments: &[Expr],
- named_arguments: &[NamedArgument],
- prefix: &[String],
- out: &mut Vec,
-) {
- for argument in arguments {
- walk_expr(argument, prefix, out);
- }
- for argument in named_arguments {
- walk_expr(&argument.value, prefix, out);
+ }),
}
}
@@ -752,6 +634,18 @@ pub(crate) fn json_str(s: &str) -> String {
#[cfg(test)]
mod tests {
use super::*;
+ /// Assert the symbol named `name` carries a doc comment mentioning `needle`
+ /// — the find-then-unwrap chain these cases otherwise repeat per symbol.
+ fn assert_doc(syms: &[SymbolInfo], name: &str, needle: &str) {
+ let doc = syms
+ .iter()
+ .find(|s| s.name == name)
+ .and_then(|s| s.doc.clone());
+ assert!(
+ doc.is_some_and(|d| d.contains(needle)),
+ "no doc mentioning {needle:?} on {name}"
+ );
+ }
#[test]
fn outline_covers_every_declaration_form() {
@@ -1005,22 +899,8 @@ print(describeAny(42) + "!")
let parsed = osprey_syntax::parse_program_with_flavor(src, osprey_syntax::Flavor::Ml);
assert!(parsed.errors.is_empty(), "{:?}", parsed.errors);
let syms = collect_all_symbols(&parsed.program);
- let doc = syms
- .iter()
- .find(|s| s.name == "double")
- .and_then(|s| s.doc.clone());
- assert!(
- doc.is_some_and(|d| d.contains("Doubles the input.")),
- "ml fn doc"
- );
- let tdoc = syms
- .iter()
- .find(|s| s.name == "Tier")
- .and_then(|s| s.doc.clone());
- assert!(
- tdoc.is_some_and(|d| d.contains("A performance tier.")),
- "ml type doc"
- );
+ assert_doc(&syms, "double", "Doubles the input.");
+ assert_doc(&syms, "Tier", "A performance tier.");
}
#[test]
@@ -1129,7 +1009,7 @@ print(describeAny(42) + "!")
clippy::too_many_lines,
reason = "exhaustive fixture: one arm per AST container variant is the point"
)]
- fn every_container_with_a_nested_let() -> Vec {
+ fn every_container_with_a_nested_let() -> Vec {
use osprey_ast::{
Expr, FieldAssignment, HandlerArm, MapEntry, MatchArm, NamedArgument, Pattern,
};
diff --git a/crates/osprey-lsp/src/diagnostics.rs b/crates/osprey-lsp/src/diagnostics.rs
index 599e1b27..2d3a6cea 100644
--- a/crates/osprey-lsp/src/diagnostics.rs
+++ b/crates/osprey-lsp/src/diagnostics.rs
@@ -110,13 +110,29 @@ fn type_diagnostics(
program: &Program,
encoding: PositionEncoding,
) -> Vec {
- osprey_types::check_program(program)
+ let mut diagnostics: Vec<_> = osprey_types::check_program(program)
.iter()
.map(|e| {
let pos = e.position.unwrap_or(Position { line: 1, column: 0 });
diagnostic(source, pos, &e.message, "type-error", encoding)
})
- .collect()
+ .collect();
+ if diagnostics.is_empty() {
+ diagnostics.extend(
+ osprey_types::redundant_annotations(program)
+ .into_iter()
+ .map(|raised| {
+ warning(
+ source,
+ raised.position.unwrap_or(Position { line: 1, column: 0 }),
+ &raised.message,
+ raised.rule,
+ encoding,
+ )
+ }),
+ );
+ }
+ diagnostics
}
/// Single-source assembly for a module-bearing file that no project claims —
@@ -194,7 +210,8 @@ fn assembled_type_errors(
project: &AssembledProject,
encoding: PositionEncoding,
) -> Vec {
- osprey_types::check_program(&project.program)
+ let errors = osprey_types::check_program(&project.program);
+ let mut diagnostics: Vec<_> = errors
.iter()
.filter_map(|error| {
let position = if let Some(global) = error.position {
@@ -217,7 +234,34 @@ fn assembled_type_errors(
encoding,
))
})
- .collect()
+ .collect();
+ if errors.is_empty() {
+ diagnostics.extend(
+ osprey_types::redundant_annotations_where(&project.program, |position| {
+ position
+ .and_then(|p| project.source_at_line(p.line))
+ .is_some_and(|(owner, _)| same_path(&owner.path, file))
+ })
+ .into_iter()
+ .filter_map(|raised| {
+ let global = raised.position?;
+ let (owner, line) = project.source_at_line(global.line)?;
+ same_path(&owner.path, file).then(|| {
+ warning(
+ source,
+ Position {
+ line,
+ column: global.column,
+ },
+ &raised.message,
+ raised.rule,
+ encoding,
+ )
+ })
+ }),
+ );
+ }
+ diagnostics
}
fn project_errors(
@@ -310,6 +354,21 @@ fn byte_col_to_encoding(line: Option<&str>, byte_col: u32, encoding: PositionEnc
.map_or(byte_col, |prefix| crate::text::measure(prefix, encoding))
}
+#[cfg(test)]
+pub(crate) fn assert_redundant_annotations(
+ actual: &[Diagnostic],
+ expected: &[(&str, crate::model::Span)],
+) {
+ assert_eq!(actual.len(), expected.len(), "{actual:?}");
+ for (diagnostic, (message, range)) in actual.iter().zip(expected) {
+ assert_eq!(diagnostic.severity, Severity::Warning, "{diagnostic:?}");
+ assert_eq!(diagnostic.code.as_deref(), Some("redundant-annotation"));
+ assert_eq!(diagnostic.source.as_deref(), Some("osprey"));
+ assert_eq!(diagnostic.message, *message);
+ assert_eq!(diagnostic.range, *range, "{diagnostic:?}");
+ }
+}
+
#[cfg(test)]
mod tests {
use super::*;
@@ -318,9 +377,16 @@ mod tests {
const OSP: &str = "file:///a.osp";
#[test]
- fn clean_program_has_no_diagnostics() {
+ fn inferred_program_is_clean_and_redundant_return_is_a_warning() {
+ assert!(compute("fn main() = print(\"hi\")\n", OSP, U16).is_empty());
let diags = compute("fn main() -> Unit = print(\"hi\")\n", OSP, U16);
- assert!(diags.is_empty(), "{diags:?}");
+ assert_redundant_annotations(
+ &diags,
+ &[(
+ "redundant return type annotation on `main`: inference derives `Unit` without it",
+ (0, 3, 0, 31),
+ )],
+ );
}
#[test]
@@ -330,10 +396,13 @@ mod tests {
// cleanly under the ML frontend rather than be flagged as broken Default
// syntax. Selecting the flavor by the document path is what fixes it.
let ml = "inc : int -> int\ninc x = (x + 1) ?: 0\nmain () =\n print \"v=${toString (inc 41)}\"\n 0\n";
- let clean = compute(ml, "file:///tour.ospml", U16);
- assert!(
- clean.is_empty(),
- "ML file should not syntax-error: {clean:?}"
+ let diagnostics = compute(ml, "file:///tour.ospml", U16);
+ assert_redundant_annotations(
+ &diagnostics,
+ &[(
+ "redundant type signature on `inc`: inference derives `(int) -> int` without it",
+ (0, 0, 0, 16),
+ )],
);
// The same source under a `.osp` path is genuinely not Default syntax, so
// the Default frontend still reports errors — proving the path drives the
@@ -343,6 +412,13 @@ mod tests {
!as_default.is_empty(),
"ML source is not valid Default syntax"
);
+ assert!(
+ as_default.iter().all(|diagnostic| {
+ diagnostic.severity == Severity::Error
+ && diagnostic.code.as_deref() == Some("syntax-error")
+ }),
+ "{as_default:?}"
+ );
}
#[test]
@@ -522,15 +598,36 @@ mod tests {
#[test]
fn module_files_use_the_assembled_project_graph() {
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../..");
- for relative in [
- "examples/projects/modules/src/main.ospml",
- "examples/projects/modules/src/web/pages.ospml",
+ let main_warnings = [
+ (
+ "redundant type signature on `bank::fetch`: inference derives `(int) -> (string) -> string` without it",
+ (20, 0, 20, 31),
+ ),
+ (
+ "redundant type signature on `bank::drive`: inference derives `(int) -> Unit` without it",
+ (32, 0, 32, 19),
+ ),
+ (
+ "redundant return type annotation on `bank::hold`: inference derives `int` without it",
+ (55, 0, 55, 9),
+ ),
+ (
+ "redundant type signature on `bank::handleRequest`: inference derives `(string, string, string, string) -> HttpResponse` without it",
+ (113, 0, 113, 68),
+ ),
+ ];
+ for (relative, expected) in [
+ (
+ "examples/projects/modules/src/main.ospml",
+ main_warnings.as_slice(),
+ ),
+ ("examples/projects/modules/src/web/pages.ospml", &[]),
] {
let path = root.join(relative);
let source = std::fs::read_to_string(&path).expect("read module example");
let uri = format!("file://{}", path.display());
let diagnostics = compute(&source, &uri, U16);
- assert!(diagnostics.is_empty(), "{relative}: {diagnostics:?}");
+ assert_redundant_annotations(&diagnostics, expected);
}
}
@@ -547,7 +644,55 @@ mod tests {
let source = std::fs::read_to_string(&path).expect("read module test suite");
let uri = format!("file://{}", path.display());
let diagnostics = compute(&source, &uri, U16);
- assert!(diagnostics.is_empty(), "{diagnostics:?}");
+ assert_redundant_annotations(
+ &diagnostics,
+ &[
+ (
+ "redundant type signature on `test::Money::pennies`: inference derives `(int) -> string` without it",
+ (8, 4, 8, 27),
+ ),
+ (
+ "redundant type signature on `test::Money::triple`: inference derives `(int) -> string` without it",
+ (15, 4, 15, 26),
+ ),
+ (
+ "redundant type signature on `test::Money::group`: inference derives `(int) -> string` without it",
+ (22, 4, 22, 25),
+ ),
+ (
+ "redundant type signature on `test::Money::show`: inference derives `(int) -> string` without it",
+ (30, 11, 30, 31),
+ ),
+ (
+ "redundant type signature on `test::Money::positive`: inference derives `(int) -> bool` without it",
+ (33, 11, 33, 33),
+ ),
+ (
+ "redundant type signature on `test::Json::escape`: inference derives `(string) -> string` without it",
+ (37, 4, 37, 29),
+ ),
+ (
+ "redundant type signature on `test::Json::quoted`: inference derives `(string) -> string` without it",
+ (44, 4, 44, 29),
+ ),
+ (
+ "redundant type signature on `test::Json::strField`: inference derives `(string) -> (string) -> string` without it",
+ (49, 11, 49, 48),
+ ),
+ (
+ "redundant type signature on `test::Json::obj`: inference derives `(string) -> string` without it",
+ (55, 11, 55, 33),
+ ),
+ (
+ "redundant type signature on `test::Accounts::movable`: inference derives `(int) -> bool` without it",
+ (73, 11, 73, 32),
+ ),
+ (
+ "redundant type signature on `test::settle`: inference derives `(test::Outcome) -> string` without it",
+ (89, 0, 89, 26),
+ ),
+ ],
+ );
}
#[cfg(unix)]
diff --git a/crates/osprey-lsp/src/engine.rs b/crates/osprey-lsp/src/engine.rs
index 2fb67404..833dc257 100644
--- a/crates/osprey-lsp/src/engine.rs
+++ b/crates/osprey-lsp/src/engine.rs
@@ -282,9 +282,25 @@ mod tests {
}
other => panic!("expected completion, got {other:?}"),
}
- // Diagnostics on a clean program are empty.
+ // [TYPE-ANNOTATION-REDUNDANT] Each written Default annotation warns.
match report(Query::Diagnostics(uri.clone())).await {
- Report::Diagnostics(diags) => assert!(diags.is_empty(), "{diags:?}"),
+ Report::Diagnostics(diags) => diagnostics::assert_redundant_annotations(
+ &diags,
+ &[
+ (
+ "redundant type annotation on parameter `a` of `add`: inference derives `int` without it",
+ (0, 3, 0, 44),
+ ),
+ (
+ "redundant type annotation on parameter `b` of `add`: inference derives `int` without it",
+ (0, 3, 0, 44),
+ ),
+ (
+ "redundant return type annotation on `add`: inference derives `int` without it",
+ (0, 3, 0, 44),
+ ),
+ ],
+ ),
other => panic!("expected diagnostics, got {other:?}"),
}
// The vfs getter exposes the shared store.
diff --git a/crates/osprey-lsp/src/features.rs b/crates/osprey-lsp/src/features.rs
index d16e2e68..045031d6 100644
--- a/crates/osprey-lsp/src/features.rs
+++ b/crates/osprey-lsp/src/features.rs
@@ -391,6 +391,7 @@ fn step_call(c: char, names: &mut Vec, commas: &mut Vec, last: &mut
mod tests {
use super::*;
use crate::hover::hover;
+ use crate::test_support::col_of;
const U16: PositionEncoding = PositionEncoding::Utf16;
const SRC: &str = "fn add(a: int, b: int) -> int = (a + b) ?: 0\nlet total = add(1, 2)\n";
@@ -474,14 +475,6 @@ mod tests {
assert!(!references.iter().any(|location| location.span.0 == 4));
}
- /// The 0-based column just inside the first occurrence of `needle` on
- /// 0-based `line` of `src` — a cursor position over that word.
- fn col_of(src: &str, line: usize, needle: &str) -> u32 {
- let text = src.lines().nth(line).expect("line exists");
- let at = text.find(needle).expect("needle on line");
- u32::try_from(at).expect("column fits") + 1
- }
-
#[test]
fn definition_and_references_return_empty_off_any_identifier() {
// A two-space gap guarantees a column that is over neither word.
diff --git a/crates/osprey-lsp/src/hover.rs b/crates/osprey-lsp/src/hover.rs
index 7ceb4401..795b3456 100644
--- a/crates/osprey-lsp/src/hover.rs
+++ b/crates/osprey-lsp/src/hover.rs
@@ -254,6 +254,8 @@ fn inferred_parameter(program: &Program, function: &str, index: usize) -> Option
#[cfg(test)]
mod tests {
use super::*;
+ use crate::test_support::col_of;
+ use crate::testkit::shows;
const U16: PositionEncoding = PositionEncoding::Utf16;
const SRC: &str = "fn add(a: int, b: int) -> int = (a + b) ?: 0\nlet total = add(1, 2)\n";
@@ -335,15 +337,13 @@ mod tests {
// does not highlight. Re-apply the flavor at the presentation edge.
let ml = "inc : int -> int\ninc x = (x + 1) ?: 0\n";
let hov = hover(ml, "file:///tour.ospml", 1, 0, U16).expect("hover");
- assert!(hov.contains("```osprey-ml"), "{hov}");
- assert!(hov.contains("inc : int -> int"), "{hov}");
+ shows(&hov, &["```osprey-ml", "inc : int -> int"]);
assert!(!hov.contains("fn inc("), "{hov}");
// The identical program under a `.osp` path keeps the Default spelling,
// proving the flavor — not the content — drives the rendering.
let default_src = "fn inc(x: int) -> int = (x + 1) ?: 0\n";
let plain = hover(default_src, "file:///a.osp", 0, 3, U16).expect("hover");
- assert!(plain.contains("```osprey\n"), "{plain}");
- assert!(plain.contains("fn inc(x: int) -> int"), "{plain}");
+ shows(&plain, &["```osprey\n", "fn inc(x: int) -> int"]);
}
#[test]
@@ -362,8 +362,7 @@ mod tests {
// Implements [LSP-HOVER-VARIABLES], [LSP-HOVER-DOCS]
let src = "fn main() -> int = {\n/// The greeting text.\nlet greeting = \"hi\"\n0\n}\n";
let md = hover(src, "file:///a.osp", 2, 6, U16).expect("hover over the `greeting` binding");
- assert!(md.contains("greeting: string"), "inferred type: {md}");
- assert!(md.contains("The greeting text."), "docs: {md}");
+ shows(&md, &["greeting: string", "The greeting text."]);
}
#[test]
@@ -372,8 +371,7 @@ mod tests {
// Implements [LSP-HOVER-DOCS]
let src = "/// Doubles `x`.\nfn dbl(x: int) -> int = (x * 2) ?: 0\n";
let md = hover(src, "file:///a.osp", 1, 4, U16).expect("hover over `dbl`");
- assert!(md.contains("fn dbl(x: int) -> int"), "signature: {md}");
- assert!(md.contains("Doubles `x`."), "docs: {md}");
+ shows(&md, &["fn dbl(x: int) -> int", "Doubles `x`."]);
let src =
include_str!("../../../tests/effects/resume/resume_outer_handler_bridge.test.osp");
@@ -423,8 +421,10 @@ mod tests {
let row = u32::try_from(line).expect("line fits");
let site = hover(src, "file:///trace.ospml", row, col, U16)
.unwrap_or_else(|| panic!("hover over effect-operation site on line {line}"));
- assert!(site.contains("Trace.mark : string => Unit"), "{site}");
- assert!(site.contains("Records trace markers."), "{site}");
+ shows(
+ &site,
+ &["Trace.mark : string => Unit", "Records trace markers."],
+ );
}
}
@@ -582,8 +582,7 @@ mod tests {
// Hovering the `int` in an annotation used to return nothing, because
// no source file declares it. Implements [LSP-HOVER-WRITTEN].
let md = hover(SRC, "file:///a.osp", 0, 11, U16).expect("hover over `int`");
- assert!(md.contains("int"), "{md}");
- assert!(md.contains("64-bit integer"), "{md}");
+ shows(&md, &["int", "64-bit integer"]);
// A declared type still resolves to its declaration, not to this table.
let declared = "type Shade = Light | Dark\nfn pick(s: Shade) = s\n";
let hovered = hover(declared, "file:///a.osp", 1, 12, U16).expect("hover over `Shade`");
@@ -630,11 +629,16 @@ test(\"identity\", fn() => expect(add(5, 0), 5))
";
let first = hover(src, "file:///suite.test.osp", 9, 1, U16).expect("hover over `test`");
assert!(first.starts_with("**Test:** commutes"), "{first}");
- assert!(first.contains("Addition is commutative."), "{first}");
- assert!(first.contains("**Parameters**"), "{first}");
- assert!(first.contains("- `left` — the first addend"), "{first}");
- assert!(first.contains("**Since**"), "{first}");
- assert!(first.contains("0.3"), "{first}");
+ shows(
+ &first,
+ &[
+ "Addition is commutative.",
+ "**Parameters**",
+ "- `left` — the first addend",
+ "**Since**",
+ "0.3",
+ ],
+ );
// The SECOND case's hover shows the second case's docs, not the first's.
let second = hover(src, "file:///suite.test.osp", 12, 1, U16).expect("hover over `test`");
assert!(second.starts_with("**Test:** identity"), "{second}");
@@ -676,8 +680,7 @@ test(\"identity\", fn() => expect(add(5, 0), 5))
// user-declared `test` binding keeps hovering as itself.
let src = "/// A local shadow.\nlet test = 1\nprint(\"${test}\")\n";
let md = hover(src, "file:///a.osp", 1, 5, U16).expect("hover over the binding");
- assert!(md.contains("test: int"), "{md}");
- assert!(md.contains("A local shadow."), "{md}");
+ shows(&md, &["test: int", "A local shadow."]);
assert!(!md.contains("**Test:**"), "not a test case: {md}");
}
@@ -695,12 +698,4 @@ test(\"identity\", fn() => expect(add(5, 0), 5))
let line = u32::try_from(index).expect("line fits");
(line, u32::try_from(at).expect("column fits") + 1)
}
-
- /// The 0-based column just inside the first occurrence of `needle` on
- /// 0-based `line` of `src` — a cursor position over that word.
- fn col_of(src: &str, line: usize, needle: &str) -> u32 {
- let text = src.lines().nth(line).expect("line exists");
- let at = text.find(needle).expect("needle on line");
- u32::try_from(at).expect("column fits") + 1
- }
}
diff --git a/crates/osprey-lsp/src/inferred_views.rs b/crates/osprey-lsp/src/inferred_views.rs
index 8737b0ae..65b56dfa 100644
--- a/crates/osprey-lsp/src/inferred_views.rs
+++ b/crates/osprey-lsp/src/inferred_views.rs
@@ -15,6 +15,7 @@
#[cfg(test)]
mod tests {
+ use crate::test_support::symbols as symbols_of;
use lspkit_vfs::PositionEncoding;
const U16: PositionEncoding = PositionEncoding::Utf16;
@@ -131,9 +132,7 @@ mod tests {
// exercises both hazards at once: the artefact `t5` and the `Unit`
// fallback that replaced it.
let src = "fn classify(xs) = match xs {\n [] => 0\n [head, ...tail] => listLength(xs)\n}\nlet e = classify([1])\n";
- let parsed = osprey_syntax::parse_program(src);
- assert!(parsed.errors.is_empty(), "{:?}", parsed.errors);
- let symbols = crate::analysis::symbols_json(&parsed.program);
+ let symbols = symbols_of(src);
let decl = crate::hover::hover(src, "file:///c.osp", 0, 4, U16).expect("hover decl");
// `xs` USED in the body, four lines from where it is bound: the two
// views of one parameter that disagreed (`List<_>` vs `List`).
@@ -201,9 +200,7 @@ mod tests {
// prints it asserts something the compiler rejects. Saying nothing is
// the only honest answer once there is nothing to say.
let src = "fn id(x) = x\nlet a = id(1)\n";
- let parsed = osprey_syntax::parse_program(src);
- assert!(parsed.errors.is_empty(), "{:?}", parsed.errors);
- let symbols = crate::analysis::symbols_json(&parsed.program);
+ let symbols = symbols_of(src);
assert!(
symbols.contains("\"signature\":\"fn id(x)\""),
"an unprovable return drops the arrow entirely: {symbols}"
@@ -230,13 +227,11 @@ mod tests {
// A hole must not carry a number, or two renderings of one type would
// disagree and an edit elsewhere would churn the tooltip.
let src = "fn pair(a, b) = [a, b]\nlet p = pair(1, 2)\n";
- let parsed = osprey_syntax::parse_program(src);
- assert!(parsed.errors.is_empty(), "{:?}", parsed.errors);
- let symbols = crate::analysis::symbols_json(&parsed.program);
+ let symbols = symbols_of(src);
assert!(!regex_like_type_var(&symbols), "{symbols}");
// Rendering the same program twice is byte-identical: nothing in the
// spelling depends on inference-run state.
- assert_eq!(symbols, crate::analysis::symbols_json(&parsed.program));
+ assert_eq!(symbols, symbols_of(src));
}
/// Whether `s` mentions an inference name (`t5`, `t42`): a `t` that starts
diff --git a/crates/osprey-lsp/src/lib.rs b/crates/osprey-lsp/src/lib.rs
index 47c7d77b..2afa8829 100644
--- a/crates/osprey-lsp/src/lib.rs
+++ b/crates/osprey-lsp/src/lib.rs
@@ -22,7 +22,12 @@ pub(crate) mod mlrender;
pub mod model;
pub(crate) mod reference_docs;
pub mod server;
+#[cfg(test)]
+mod test_support;
pub mod testing;
+#[cfg(test)]
+#[path = "../../testkit.rs"]
+mod testkit;
pub mod text;
pub(crate) mod wire;
pub mod workspace;
diff --git a/crates/osprey-lsp/src/server.rs b/crates/osprey-lsp/src/server.rs
index 6d63d31d..527e2c03 100644
--- a/crates/osprey-lsp/src/server.rs
+++ b/crates/osprey-lsp/src/server.rs
@@ -210,37 +210,28 @@ async fn publish(engine: &OspreyEngine, bus: &lspkit_server::DiagnosticsBus, doc
/// Implements [LSP-CAPABILITIES].
fn build_dispatcher(engine: &OspreyEngine) -> Dispatcher {
let dispatcher = Dispatcher::new();
- register(
+ positional(
&dispatcher,
engine,
"textDocument/hover",
- |e, p, c| async move {
- Some(result(hover_value(
- answer(&e, Query::Hover(at(&p)?), c).await,
- )))
- },
+ Query::Hover,
+ hover_value,
);
- register(
+ positional(
&dispatcher,
engine,
"textDocument/definition",
- |e, p, c| async move {
- Some(result(locations_value(
- answer(&e, Query::Definition(at(&p)?), c).await,
- )))
- },
+ Query::Definition,
+ locations_value,
);
// Standard implementation-provider routing makes VS Code expose its native
// context-menu action. [LSP-IMPLEMENTATIONS-EFFECT-HANDLERS]
- register(
+ positional(
&dispatcher,
engine,
"textDocument/implementation",
- |e, p, c| async move {
- Some(result(locations_value(
- answer(&e, Query::Implementation(at(&p)?), c).await,
- )))
- },
+ Query::Implementation,
+ locations_value,
);
register(
&dispatcher,
@@ -254,15 +245,12 @@ fn build_dispatcher(engine: &OspreyEngine) -> Dispatcher {
Some(result(locations_value(answer(&e, query, c).await)))
},
);
- register(
+ positional(
&dispatcher,
engine,
"textDocument/signatureHelp",
- |e, p, c| async move {
- Some(result(signature_value(
- answer(&e, Query::SignatureHelp(at(&p)?), c).await,
- )))
- },
+ Query::SignatureHelp,
+ signature_value,
);
register(
&dispatcher,
@@ -277,15 +265,12 @@ fn build_dispatcher(engine: &OspreyEngine) -> Dispatcher {
)))
},
);
- register(
+ positional(
&dispatcher,
engine,
"textDocument/completion",
- |e, p, c| async move {
- Some(result(completion_value(
- answer(&e, Query::Completion(at(&p)?), c).await,
- )))
- },
+ Query::Completion,
+ completion_value,
);
register(
&dispatcher,
@@ -301,6 +286,21 @@ fn build_dispatcher(engine: &OspreyEngine) -> Dispatcher {
dispatcher
}
+/// Register a request whose whole handling is "read a position, ask the engine
+/// one query, render the answer" — the shape every purely positional method
+/// shares. The three things that differ are its arguments.
+fn positional(
+ dispatcher: &Dispatcher,
+ engine: &OspreyEngine,
+ method: &str,
+ query: fn(At) -> Query,
+ render: fn(Option) -> Value,
+) {
+ register(dispatcher, engine, method, move |e, p, c| async move {
+ Some(result(render(answer(&e, query(at(&p)?), c).await)))
+ });
+}
+
/// Register one handler. The closure receives a cloned engine, the params, and
/// a cancellation token, and returns the JSON result.
fn register(dispatcher: &Dispatcher, engine: &OspreyEngine, method: &str, handler: F)
@@ -607,21 +607,38 @@ mod tests {
}
#[tokio::test]
- async fn did_open_publishes_clean_diagnostics_then_errors_on_change() {
+ async fn did_open_publishes_warnings_then_errors_on_change() {
// Document synchronization drives compiler diagnostics.
// [LSP-LIFECYCLE], [LSP-DIAGNOSTICS]
let mut h = Harness::start();
- let clean = h.open(SRC).await;
+ let opened = h.open(SRC).await;
assert_eq!(
- clean.method.as_deref(),
+ opened.method.as_deref(),
Some("textDocument/publishDiagnostics")
);
- let params = clean.params.expect("diagnostics params");
+ let params = opened.params.expect("diagnostics params");
assert_at(¶ms, "/uri", URI);
+ let expected: Vec<_> = [
+ "redundant type annotation on parameter `a` of `add`: inference derives `int` without it",
+ "redundant type annotation on parameter `b` of `add`: inference derives `int` without it",
+ "redundant return type annotation on `add`: inference derives `int` without it",
+ ]
+ .into_iter()
+ .map(|message| json!({
+ "code": "redundant-annotation",
+ "message": message,
+ "range": {
+ "start": { "line": 0, "character": 3 },
+ "end": { "line": 0, "character": 44 }
+ },
+ "severity": 2,
+ "source": "osprey"
+ }))
+ .collect();
assert_eq!(
params.pointer("/diagnostics").and_then(Value::as_array),
- Some(&Vec::new()),
- "clean program has no diagnostics"
+ Some(&expected),
+ "redundant annotations publish precise warnings"
);
// The engine now has the open document text.
assert_eq!(
diff --git a/crates/osprey-lsp/src/test_support.rs b/crates/osprey-lsp/src/test_support.rs
new file mode 100644
index 00000000..ca9e3041
--- /dev/null
+++ b/crates/osprey-lsp/src/test_support.rs
@@ -0,0 +1,30 @@
+//! Test-only helpers shared by the editor-feature unit tests.
+//!
+//! Every feature test opens the same way: parse a snippet, fail loudly on any
+//! syntax error, then ask one editor question about a cursor position. Each
+//! `mod tests` used to carry its own copy of that preamble, so the copies
+//! drifted apart on their failure messages while asserting the same thing.
+
+use osprey_ast::Program;
+
+/// Parse `src`, asserting it is syntactically valid. A snippet the PARSER
+/// rejects must never be scored as a passing editor view.
+pub(crate) fn parsed(src: &str) -> Program {
+ let parsed = osprey_syntax::parse_program(src);
+ assert!(parsed.errors.is_empty(), "{:?}", parsed.errors);
+ parsed.program
+}
+
+/// The symbol view of a valid snippet — the rendering the inference-view tests
+/// inspect.
+pub(crate) fn symbols(src: &str) -> String {
+ crate::analysis::symbols_json(&parsed(src))
+}
+
+/// The 0-based column just inside the first occurrence of `needle` on 0-based
+/// `line` of `src` — a cursor position over that word.
+pub(crate) fn col_of(src: &str, line: usize, needle: &str) -> u32 {
+ let text = src.lines().nth(line).expect("line exists");
+ let at = text.find(needle).expect("needle on line");
+ u32::try_from(at).expect("column fits") + 1
+}
diff --git a/crates/osprey-lsp/src/testing.rs b/crates/osprey-lsp/src/testing.rs
index 46aacf36..460170de 100644
--- a/crates/osprey-lsp/src/testing.rs
+++ b/crates/osprey-lsp/src/testing.rs
@@ -338,6 +338,7 @@ pub(crate) fn test_case_hover(program: &Program, line: u32) -> Option {
)]
mod tests {
use super::*;
+ use crate::testkit::shows;
use osprey_syntax::{parse_program, parse_program_with_flavor, Flavor};
fn program(src: &str) -> Program {
@@ -722,8 +723,7 @@ test(\"undocumented\", fn() => expect(add(1, 1), 2))
let program = program(DOCUMENTED);
let hov = test_case_hover(&program, 22).expect("hover on the `test(` line");
assert!(hov.starts_with("**Test:** commutes"), "{hov}");
- assert!(hov.contains("Addition is commutative."), "{hov}");
- assert!(hov.contains("**Parameters**"), "full doc, not just summary");
+ shows(&hov, &["Addition is commutative.", "**Parameters**"]);
// A line with no test case declared on it has no test hover at all.
assert_eq!(test_case_hover(&program, 1), None);
assert_eq!(test_case_hover(&program, 999), None);
diff --git a/crates/osprey-profiler/src/lib.rs b/crates/osprey-profiler/src/lib.rs
index 9240fd43..f9c1282b 100644
--- a/crates/osprey-profiler/src/lib.rs
+++ b/crates/osprey-profiler/src/lib.rs
@@ -17,6 +17,9 @@ mod symbolize;
#[cfg(test)]
mod e2e;
#[cfg(test)]
+#[path = "../../testkit.rs"]
+mod testkit;
+#[cfg(test)]
pub(crate) mod testutil;
use std::fmt;
diff --git a/crates/osprey-profiler/src/report.rs b/crates/osprey-profiler/src/report.rs
index 929564cf..92db0c27 100644
--- a/crates/osprey-profiler/src/report.rs
+++ b/crates/osprey-profiler/src/report.rs
@@ -184,6 +184,7 @@ mod tests {
use crate::model::build_model;
use crate::raw::Profile;
use crate::symbolize::SymFrame;
+ use crate::testkit::shows;
use crate::testutil::{model_of, osp_frame, profile, sample, thread};
/// 200 on-CPU samples on main (no low-sample note): 100 leaf on parse
@@ -278,8 +279,7 @@ mod tests {
report.contains("\x1b[33m"),
"warm row must be yellow: {report}"
);
- assert!(report.contains("\x1b[2m"), "cold row must be dim: {report}");
- assert!(report.contains(RESET));
+ shows(&report, &["\x1b[2m", RESET]);
}
#[test]
@@ -300,17 +300,19 @@ mod tests {
#[test]
fn zero_oncpu_samples_report_full_uncertainty() {
let report = render_report("fib.osp", "fib", &tiny_model(0), false);
- assert!(report.contains("±100.0%"), "{report}");
- assert!(report.contains("0 samples @ 1000Hz · 1 fiber"), "{report}");
+ shows(&report, &["±100.0%", "0 samples @ 1000Hz · 1 fiber"]);
}
#[test]
fn footer_names_the_exports_and_viewers() {
let report = render(false);
- assert!(report.contains("profile: fib.speedscope.json · fib.cpuprofile · fib.folded"));
- assert!(report.contains(
- "view: https://speedscope.app (drag the file) or open fib.cpuprofile in VS Code"
- ));
+ shows(
+ &report,
+ &[
+ "profile: fib.speedscope.json · fib.cpuprofile · fib.folded",
+ "view: https://speedscope.app (drag the file) or open fib.cpuprofile in VS Code",
+ ],
+ );
}
#[test]
diff --git a/crates/osprey-profiler/src/symbolize/mod.rs b/crates/osprey-profiler/src/symbolize/mod.rs
index 0aaf5dff..bb3eb05d 100644
--- a/crates/osprey-profiler/src/symbolize/mod.rs
+++ b/crates/osprey-profiler/src/symbolize/mod.rs
@@ -226,6 +226,20 @@ fn lookup_chain(profile: &Profile, cache: &ChainCache, index: usize, pc: u64) ->
#[cfg(test)]
mod tests {
use super::*;
+ /// An image loaded at `base` (after `slide`) whose executable range spans
+ /// `text .. text + text_size`. Every case here varies only these five
+ /// fields, so the zeroed remainder is written once instead of per literal.
+ fn image(path: &str, base: u64, slide: u64, text: u64, text_size: u64) -> Image {
+ Image {
+ path: path.to_owned(),
+ base,
+ slide,
+ text,
+ text_size,
+ arch: String::new(),
+ }
+ }
+
use crate::raw::{Sample, Thread};
use std::cell::RefCell;
@@ -281,24 +295,7 @@ mod tests {
#[test]
fn pcs_fall_back_to_greatest_base_when_no_image_reports_a_text_range() {
- let images = vec![
- Image {
- path: "/a".to_owned(),
- base: 100,
- slide: 0,
- text: 0,
- text_size: 0,
- arch: String::new(),
- },
- Image {
- path: "/b".to_owned(),
- base: 500,
- slide: 0,
- text: 0,
- text_size: 0,
- arch: String::new(),
- },
- ];
+ let images = vec![image("/a", 100, 0, 0, 0), image("/b", 500, 0, 0, 0)];
assert_eq!(image_index_for(&images, 499), Some(0));
assert_eq!(image_index_for(&images, 500), Some(1));
assert_eq!(image_index_for(&images, 99), None);
@@ -316,22 +313,20 @@ mod tests {
#[test]
fn a_shared_cache_pc_is_owned_by_the_image_whose_text_contains_it() {
let images = vec![
- Image {
- path: "/usr/lib/system/libsystem_malloc.dylib".to_owned(),
- base: 0x1_8000_0000,
- slide: 0,
- text: 0x1_8030_0000,
- text_size: 0x2_0000,
- arch: String::new(),
- },
- Image {
- path: "/usr/lib/system/libsystem_kernel.dylib".to_owned(),
- base: 0x1_8010_0000,
- slide: 0,
- text: 0x1_8040_0000,
- text_size: 0x2_0000,
- arch: String::new(),
- },
+ image(
+ "/usr/lib/system/libsystem_malloc.dylib",
+ 0x1_8000_0000,
+ 0,
+ 0x1_8030_0000,
+ 0x2_0000,
+ ),
+ image(
+ "/usr/lib/system/libsystem_kernel.dylib",
+ 0x1_8010_0000,
+ 0,
+ 0x1_8040_0000,
+ 0x2_0000,
+ ),
];
// The observed leaf: inside libsystem_malloc's __TEXT, but BELOW the
// kernel image's header, which is what the old rule keyed on.
@@ -346,14 +341,7 @@ mod tests {
/// the end is not.
#[test]
fn a_reported_text_range_is_half_open() {
- let image = Image {
- path: "/bin/app".to_owned(),
- base: 0,
- slide: 0,
- text: 0x4000,
- text_size: 0x1000,
- arch: String::new(),
- };
+ let image = image("/bin/app", 0, 0, 0x4000, 0x1000);
assert!(image.text_contains(0x4000));
assert!(image.text_contains(0x4FFF));
assert!(!image.text_contains(0x5000));
@@ -381,22 +369,8 @@ mod tests {
rate_hz: 997,
dropped: 0,
images: vec![
- Image {
- path: "/bin/app".to_owned(),
- base: 1000,
- slide: 100,
- text: 0,
- text_size: 0,
- arch: String::new(),
- },
- Image {
- path: "/usr/lib/sys".to_owned(),
- base: 9000,
- slide: 0,
- text: 0,
- text_size: 0,
- arch: String::new(),
- },
+ image("/bin/app", 1000, 100, 0, 0),
+ image("/usr/lib/sys", 9000, 0, 0, 0),
],
threads: vec![Thread {
fiber: 0,
diff --git a/crates/osprey-project/src/annotation.rs b/crates/osprey-project/src/annotation.rs
index 3e02f25a..793679a4 100644
--- a/crates/osprey-project/src/annotation.rs
+++ b/crates/osprey-project/src/annotation.rs
@@ -23,7 +23,7 @@ impl Resolver<'_> {
) {
match (statement, annotation) {
(Stmt::Let { ty, .. }, SignatureItem::Value { ty: contract, .. }) if ty.is_none() => {
- *ty = Some(contract.clone());
+ *ty = Some(contract.as_contract_annotation());
}
(
Stmt::Function {
@@ -49,11 +49,11 @@ impl Resolver<'_> {
}
for (parameter, contract) in parameters.iter_mut().zip(contracts) {
if parameter.ty.is_none() {
- parameter.ty = Some(contract.clone());
+ parameter.ty = Some(contract.as_contract_annotation());
}
}
if return_type.is_none() {
- *return_type = Some(contract_return.clone());
+ *return_type = Some(contract_return.as_contract_annotation());
}
if effects.is_empty() {
effects.clone_from(contract_effects);
diff --git a/crates/osprey-project/src/imports.rs b/crates/osprey-project/src/imports.rs
index f2d9ba04..14e7aec3 100644
--- a/crates/osprey-project/src/imports.rs
+++ b/crates/osprey-project/src/imports.rs
@@ -15,19 +15,19 @@ pub(crate) struct ImportScope {
}
impl ImportScope {
- pub fn alias(&self, name: &str) -> Option<&SymbolKey> {
+ pub(crate) fn alias(&self, name: &str) -> Option<&SymbolKey> {
self.aliases.get(name)
}
- pub fn member(&self, name: &str) -> Option<&SymbolKey> {
+ pub(crate) fn member(&self, name: &str) -> Option<&SymbolKey> {
self.members.get(name)
}
- pub fn is_ambiguous(&self, name: &str) -> bool {
+ pub(crate) fn is_ambiguous(&self, name: &str) -> bool {
self.ambiguous.contains(name)
}
- pub fn aliases_for(&self, target: &SymbolKey) -> Vec {
+ pub(crate) fn aliases_for(&self, target: &SymbolKey) -> Vec {
self.aliases
.iter()
.filter(|(_, candidate)| *candidate == target)
diff --git a/crates/osprey-project/src/model.rs b/crates/osprey-project/src/model.rs
index 8f102957..d6c27b0b 100644
--- a/crates/osprey-project/src/model.rs
+++ b/crates/osprey-project/src/model.rs
@@ -13,26 +13,26 @@ pub(crate) struct SymbolKey {
}
impl SymbolKey {
- pub fn new(namespace: impl Into, path: Vec) -> Self {
+ pub(crate) fn new(namespace: impl Into, path: Vec) -> Self {
Self {
namespace: namespace.into(),
path,
}
}
- pub fn child(&self, name: impl Into) -> Self {
+ pub(crate) fn child(&self, name: impl Into) -> Self {
let mut path = self.path.clone();
path.push(name.into());
Self::new(self.namespace.clone(), path)
}
- pub fn parent_path(&self) -> &[String] {
+ pub(crate) fn parent_path(&self) -> &[String] {
self.path
.get(..self.path.len().saturating_sub(1))
.unwrap_or_default()
}
- pub fn source_name(&self) -> String {
+ pub(crate) fn source_name(&self) -> String {
std::iter::once(self.namespace.as_str())
.chain(self.path.iter().map(String::as_str))
.filter(|segment| !segment.is_empty())
@@ -40,7 +40,7 @@ impl SymbolKey {
.join("::")
}
- pub fn mangled(&self) -> String {
+ pub(crate) fn mangled(&self) -> String {
osprey_ast::symbol::mangle(
std::iter::once(self.namespace.as_str()).chain(self.path.iter().map(String::as_str)),
)
@@ -70,7 +70,7 @@ pub(crate) struct DeclInfo {
}
impl DeclInfo {
- pub fn visible_from(&self, same_namespace: bool, module: &[String]) -> bool {
+ pub(crate) fn visible_from(&self, same_namespace: bool, module: &[String]) -> bool {
self.visibility == Visibility::Exported
|| (same_namespace && module.starts_with(&self.owner))
}
diff --git a/crates/osprey-project/src/name_resolve.rs b/crates/osprey-project/src/name_resolve.rs
index 9b7d5db8..389fc810 100644
--- a/crates/osprey-project/src/name_resolve.rs
+++ b/crates/osprey-project/src/name_resolve.rs
@@ -6,7 +6,7 @@ use crate::resolve::{Context, Resolver};
use osprey_ast::Position;
impl Resolver<'_> {
- pub fn resolve_bare(
+ pub(crate) fn resolve_bare(
&mut self,
name: &str,
context: &Context,
@@ -32,7 +32,7 @@ impl Resolver<'_> {
scope.and_then(|scope| scope.member(name)).cloned()
}
- pub fn resolve_path(
+ pub(crate) fn resolve_path(
&mut self,
segments: &[String],
context: &Context,
@@ -72,7 +72,12 @@ impl Resolver<'_> {
None
}
- pub fn rewrite_value_name(&mut self, name: &mut String, context: &Context, required: bool) {
+ pub(crate) fn rewrite_value_name(
+ &mut self,
+ name: &mut String,
+ context: &Context,
+ required: bool,
+ ) {
let key = if name.contains("::") {
let segments = name.split("::").map(str::to_string).collect::>();
self.resolve_path(&segments, context, None)
diff --git a/crates/osprey-project/src/resolve.rs b/crates/osprey-project/src/resolve.rs
index ec4cd3f5..90720b0c 100644
--- a/crates/osprey-project/src/resolve.rs
+++ b/crates/osprey-project/src/resolve.rs
@@ -356,7 +356,7 @@ impl Resolver<'_> {
self.entry_locals = locals;
}
- pub fn link_name(&mut self, key: &SymbolKey, entry_main: bool) -> String {
+ pub(crate) fn link_name(&mut self, key: &SymbolKey, entry_main: bool) -> String {
let name = if entry_main {
"main".to_string()
} else if self
@@ -373,7 +373,12 @@ impl Resolver<'_> {
name
}
- pub fn error(&mut self, source: usize, position: Option, message: impl Into) {
+ pub(crate) fn error(
+ &mut self,
+ source: usize,
+ position: Option,
+ message: impl Into,
+ ) {
self.errors
.push(source_error(self.sources, source, position, message));
}
diff --git a/crates/osprey-project/src/rewrite.rs b/crates/osprey-project/src/rewrite.rs
index 4bfd0fc1..ca109cdf 100644
--- a/crates/osprey-project/src/rewrite.rs
+++ b/crates/osprey-project/src/rewrite.rs
@@ -18,7 +18,7 @@ fn locals_with_type_parameters(type_params: &[TypeParam]) -> Locals {
impl Resolver<'_> {
/// Resolves a constant initializer and rejects active-path recursion.
/// Implements the constant half of [MODULES-CYCLES].
- pub fn constant_value(&mut self, key: &SymbolKey) -> Option {
+ pub(crate) fn constant_value(&mut self, key: &SymbolKey) -> Option {
if let Some(value) = self.constant_cache.get(key) {
return Some(value.clone());
}
@@ -72,7 +72,7 @@ impl Resolver<'_> {
clippy::too_many_lines,
reason = "declaration rewriting is an exhaustive canonical AST match"
)]
- pub fn rewrite_declaration(
+ pub(crate) fn rewrite_declaration(
&mut self,
statement: &mut Stmt,
context: &Context,
@@ -202,7 +202,7 @@ impl Resolver<'_> {
}
}
- pub fn rewrite_local_statement(
+ pub(crate) fn rewrite_local_statement(
&mut self,
statement: &mut Stmt,
context: &Context,
@@ -243,7 +243,12 @@ impl Resolver<'_> {
clippy::too_many_lines,
reason = "expression rewriting is an exhaustive canonical AST walk"
)]
- pub fn rewrite_expr(&mut self, expression: &mut Expr, context: &Context, locals: &mut Locals) {
+ pub(crate) fn rewrite_expr(
+ &mut self,
+ expression: &mut Expr,
+ context: &Context,
+ locals: &mut Locals,
+ ) {
if let Expr::Identifier(name) = expression {
let name = name.clone();
let mut rewritten = Expr::Identifier(name.clone());
@@ -288,6 +293,19 @@ impl Resolver<'_> {
self.rewrite_expr(left, context, locals);
self.rewrite_expr(right, context, locals);
}
+ Expr::TypeApply {
+ function,
+ type_args,
+ ..
+ } => {
+ self.rewrite_expr(function, context, locals);
+ if let Expr::FieldAccess { field, .. } = function.as_mut() {
+ self.rewrite_value_name(field, context, false);
+ }
+ for argument in type_args {
+ self.rewrite_type(argument, context, locals);
+ }
+ }
Expr::Unary { operand, .. }
| Expr::Spawn(operand)
| Expr::Await(operand)
diff --git a/crates/osprey-project/src/span.rs b/crates/osprey-project/src/span.rs
index bd842b81..b2f12520 100644
--- a/crates/osprey-project/src/span.rs
+++ b/crates/osprey-project/src/span.rs
@@ -181,7 +181,9 @@ fn optional_type(ty: &mut Option, offset: u32) {
}
fn offset_type(ty: &mut TypeExpr, offset: u32) {
- shift(&mut ty.position, offset);
+ if !ty.is_from_contract() {
+ shift(&mut ty.position, offset);
+ }
for parameter in &mut ty.generic_params {
offset_type(parameter, offset);
}
@@ -232,6 +234,17 @@ fn offset_expr(expr: &mut Expr, offset: u32) {
offset_expr(left, offset);
offset_expr(right, offset);
}
+ Expr::TypeApply {
+ function,
+ type_args,
+ position,
+ } => {
+ shift(position, offset);
+ for argument in type_args {
+ offset_type(argument, offset);
+ }
+ offset_expr(function, offset);
+ }
Expr::Unary { operand, .. }
| Expr::Spawn(operand)
| Expr::Await(operand)
diff --git a/crates/osprey-project/src/state.rs b/crates/osprey-project/src/state.rs
index d78b38b1..8a6d8ab9 100644
--- a/crates/osprey-project/src/state.rs
+++ b/crates/osprey-project/src/state.rs
@@ -229,7 +229,12 @@ impl<'a> Inspector<'a> {
self.expr(left, in_owner_arm, position);
self.expr(right, in_owner_arm, position);
}
- Expr::Unary { operand, .. } | Expr::Await(operand) | Expr::Recv(operand) => {
+ Expr::TypeApply {
+ function: operand, ..
+ }
+ | Expr::Unary { operand, .. }
+ | Expr::Await(operand)
+ | Expr::Recv(operand) => {
self.expr(operand, in_owner_arm, position);
}
Expr::Spawn(operand) => self.escaping(operand, position),
diff --git a/crates/osprey-project/src/type_rewrite.rs b/crates/osprey-project/src/type_rewrite.rs
index a81b8aa7..2849e0e4 100644
--- a/crates/osprey-project/src/type_rewrite.rs
+++ b/crates/osprey-project/src/type_rewrite.rs
@@ -6,7 +6,12 @@ use osprey_ast::{EffectRef, TypeExpr};
use std::collections::BTreeMap;
impl Resolver<'_> {
- pub fn rewrite_type(&mut self, ty: &mut TypeExpr, context: &Context, locals: &mut Locals) {
+ pub(crate) fn rewrite_type(
+ &mut self,
+ ty: &mut TypeExpr,
+ context: &Context,
+ locals: &mut Locals,
+ ) {
for parameter in &mut ty.generic_params {
self.rewrite_type(parameter, context, locals);
}
@@ -47,7 +52,7 @@ impl Resolver<'_> {
ty.name = self.link_name(&key, false);
}
- pub fn rewrite_effect_refs(
+ pub(crate) fn rewrite_effect_refs(
&mut self,
effects: &mut [EffectRef],
context: &Context,
@@ -83,7 +88,7 @@ impl Resolver<'_> {
}
}
- pub fn rewrite_type_text(
+ pub(crate) fn rewrite_type_text(
&mut self,
text: &str,
context: &Context,
diff --git a/crates/osprey-syntax/src/default/expr.rs b/crates/osprey-syntax/src/default/expr.rs
index 93d6e1c2..1c0e3f6c 100644
--- a/crates/osprey-syntax/src/default/expr.rs
+++ b/crates/osprey-syntax/src/default/expr.rs
@@ -199,7 +199,7 @@ impl Lowerer<'_> {
}
fn lower_call(&self, node: Node<'_>) -> Expr {
- let callee = self.lower_expr_field(node, "callee");
+ let mut callee = self.lower_expr_field(node, "callee");
if let Some(member) = node.child_by_field_name("member") {
return Expr::FieldAccess {
target: Box::new(callee),
@@ -212,20 +212,28 @@ impl Lowerer<'_> {
index: Box::new(self.lower_expr(index)),
};
}
- // function/method call. UFCS [BUILTIN-STRING-UFCS]: `x.f(a, …)` is
- // sugar for `f(x, a, …)`, so a
- // field-access callee lowers to an ordinary call with the receiver as the
- // first positional argument — keeping method calls invisible downstream.
- let (mut arguments, named_arguments) = self.lower_arg_list(node);
+ // Keep an ordinary dotted call until inference can distinguish a
+ // callable record field from receiver-first sugar [BUILTIN-STRING-UFCS].
+ // Written type arguments apply a named function's declared binders.
+ let (arguments, named_arguments) = self.lower_arg_list(node);
+ if let Some(args) = node.child_by_field_name("type_arguments") {
+ callee = Expr::TypeApply {
+ function: Box::new(callee),
+ type_args: self
+ .named_of_kind(args, "type_list")
+ .into_iter()
+ .flat_map(|list| self.lower_type_list(list))
+ .collect(),
+ position: Some(self.pos(node)),
+ };
+ }
match callee {
- Expr::FieldAccess { target, field } => {
- arguments.insert(0, *target);
- Expr::Call {
- function: Box::new(Expr::Identifier(field)),
- arguments,
- named_arguments,
- }
- }
+ Expr::FieldAccess { target, field } => Expr::MethodCall {
+ target,
+ method: field,
+ arguments,
+ named_arguments,
+ },
// A saturated call of a positionally-declared constructor is a
// construction, not a call ([TYPE-UNION-POSITIONAL]) — the one
// call-shaped expression exempt from the named-argument rule,
@@ -453,7 +461,10 @@ fn fragment_prefix() -> u32 {
}
fn parse_fragment(frag: &str) -> Expr {
- let parsed = crate::parse_program(&format!("{FRAGMENT_BINDING}{frag}\n"));
+ let parsed = super::parse(&format!("{FRAGMENT_BINDING}{frag}\n"));
+ if !parsed.errors.is_empty() {
+ return Expr::Identifier(frag.trim().to_owned());
+ }
match parsed.program.statements.into_iter().next() {
Some(Stmt::Let { value, .. }) => value,
_ => Expr::Identifier(frag.trim().to_string()),
@@ -605,18 +616,17 @@ mod tests {
Expr::Call { arguments, .. } => assert_eq!(arguments.len(), 2),
other => panic!("expected call, got {other:?}"),
}
- // UFCS field-access call `o.m(1)` -> Call(m, [o, 1]).
- match let_value("let r = o.m(1)\n") {
- Expr::Call {
- function,
- arguments,
- ..
- } => {
- assert!(matches!(*function, Expr::Identifier(ref n) if n == "m"));
- assert_eq!(arguments.len(), 2);
+ // [BUILTIN-STRING-UFCS] Preserve the receiver until type checking can
+ // select its callable field or the free-function fallback.
+ assert_eq!(
+ let_value("let r = o.m(1)\n"),
+ Expr::MethodCall {
+ target: Box::new(Expr::Identifier("o".into())),
+ method: "m".into(),
+ arguments: vec![Expr::Integer(1)],
+ named_arguments: vec![],
}
- other => panic!("expected call, got {other:?}"),
- }
+ );
// Plain field access and indexing.
assert!(matches!(
let_value("let r = o.field\n"),
diff --git a/crates/osprey-syntax/src/default/lower.rs b/crates/osprey-syntax/src/default/lower.rs
index 6ae8f5f2..d0d804f3 100644
--- a/crates/osprey-syntax/src/default/lower.rs
+++ b/crates/osprey-syntax/src/default/lower.rs
@@ -26,7 +26,7 @@ fn strip_doc_line(line: &str) -> &str {
/// Holds the source bytes so node text can be sliced during lowering.
#[derive(Debug)]
-pub struct Lowerer<'a> {
+pub(crate) struct Lowerer<'a> {
src: &'a [u8],
}
@@ -764,7 +764,7 @@ fn negate_literal(e: Expr) -> Expr {
)]
mod tests {
use crate::parse_tree;
- use crate::test_support::{one_stmt, stmts};
+ use crate::test_support::{assert_doc_pair, assert_summary, one_stmt, stmt_doc, stmts};
use osprey_ast::{Expr, Pattern, Stmt};
use tree_sitter::Node;
@@ -780,16 +780,6 @@ mod tests {
// ---------- [TESTING-DOC] expression-statement documentation ----------
- /// The doc comment lowered onto a statement, or `None`.
- fn stmt_doc(stmt: &Stmt) -> Option<&osprey_ast::DocComment> {
- match stmt {
- Stmt::Expr { doc, .. } | Stmt::Let { doc, .. } | Stmt::Function { doc, .. } => {
- doc.as_ref()
- }
- _ => None,
- }
- }
-
#[test]
fn a_doc_comment_lowers_onto_the_expression_statement_it_precedes() {
// A `test(...)` case is an expression statement, not a declaration, so
@@ -836,15 +826,9 @@ mod tests {
fn each_documented_statement_owns_only_its_own_doc() {
let all = stmts("/// First.\ntest(\"a\", 1)\ntest(\"b\", 2)\n/// Third.\ntest(\"c\", 3)\n");
assert_eq!(all.len(), 3);
- assert_eq!(
- stmt_doc(&all[0]).map(|d| d.summary.as_str()),
- Some("First.")
- );
- assert_eq!(stmt_doc(&all[1]).map(|d| d.summary.as_str()), None);
- assert_eq!(
- stmt_doc(&all[2]).map(|d| d.summary.as_str()),
- Some("Third.")
- );
+ assert_summary(&all[0], Some("First."));
+ assert_summary(&all[1], None);
+ assert_summary(&all[2], Some("Third."));
}
#[test]
@@ -852,13 +836,7 @@ mod tests {
// Adding the expression-statement slot must not steal a following
// declaration's doc comment.
let all = stmts("/// Runs it.\nprint(\"hi\")\n/// Adds.\nfn add(a, b) = a + b\n");
- assert_eq!(all.len(), 2);
- assert_eq!(
- stmt_doc(&all[0]).map(|d| d.summary.as_str()),
- Some("Runs it.")
- );
- assert!(matches!(all[1], Stmt::Function { .. }));
- assert_eq!(stmt_doc(&all[1]).map(|d| d.summary.as_str()), Some("Adds."));
+ assert_doc_pair(&all, "Runs it.", "Adds.");
}
#[test]
@@ -870,10 +848,7 @@ mod tests {
let Expr::Block { statements, .. } = body else {
panic!("expected a block body, got {body:?}");
};
- assert_eq!(
- stmt_doc(&statements[0]).map(|d| d.summary.as_str()),
- Some("Inner case.")
- );
+ assert_summary(&statements[0], Some("Inner case."));
}
#[test]
diff --git a/crates/osprey-syntax/src/default/mod.rs b/crates/osprey-syntax/src/default/mod.rs
index 53b04a2e..3d9d6179 100644
--- a/crates/osprey-syntax/src/default/mod.rs
+++ b/crates/osprey-syntax/src/default/mod.rs
@@ -67,6 +67,10 @@ pub fn parse_tree(source: &str) -> Option {
}
fn collect_errors(node: Node<'_>, src: &[u8], out: &mut Vec) {
+ if let Some(error) = call_variance_error(node, src) {
+ out.push(error);
+ return;
+ }
if node.is_error() || node.is_missing() {
let p = node.start_position();
out.push(SyntaxError {
@@ -113,6 +117,22 @@ fn collect_errors(node: Node<'_>, src: &[u8], out: &mut Vec) {
}
}
+/// Variance declares a binder; it cannot decorate a call's type argument.
+fn call_variance_error(node: Node<'_>, src: &[u8]) -> Option