ab4f826 | plum

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

ab4f826 — Peter John 2026-07-21T10:53:09+05:30

fix editor

Files changed (7) hide show

.recall/.capture.json +1 -1
.recall/history.md +160 -0
plum-cli/src/editor.rs +22 -1
tooling/tree-sitter-plum/Makefile +6 -4
tooling/tree-sitter-plum/queries/plum/highlights.scm +25 -1
tooling/tree-sitter-plum/queries/plum/tags.scm +9 -0
tooling/tree-sitter-plum/queries/plum/textobjects.scm +17 -0

.recall/.capture.json CHANGED Viewed

	@@ -1 +1 @@
1	- {"505dc4d5-42ca-45dc-8df3-1f5e1b1c5bc6": 1886367, "78fe4b8b-6ba2-4a17-b415-0bf00e4a0f4d": 4168472, "61ed18b5-cab0-453c-9a65-dcb8cfc58361": 5702751, "4126b3b8-6d8e-4ca3-8898-fa4ab65a979c": ~~2221039~~}
1	+ {"505dc4d5-42ca-45dc-8df3-1f5e1b1c5bc6": 1886367, "78fe4b8b-6ba2-4a17-b415-0bf00e4a0f4d": 4168472, "61ed18b5-cab0-453c-9a65-dcb8cfc58361": 5702751, "4126b3b8-6d8e-4ca3-8898-fa4ab65a979c": 2683872}

.recall/history.md CHANGED Viewed

@@ -7589,3 +7589,163 @@ Confirmed by checking `runtime/grammars/` directly (no `plum.so` there) and then
 **Fix**: [`plum editor helix`](plum-cli/src/editor.rs) now runs `hx --grammar build` automatically at the end of install, instead of just printing a hint to do it yourself. Verified by deleting `plum.so` and re-running the real install command — it rebuilt just the missing `plum` grammar and left the other 244 already-built ones alone.
 Your Plum syntax should now actually highlight — reopen the `.plum` file (or restart Helix). One remaining gap: `hx --health` still shows `Textobject queries: ✘` since there's no `textobjects.scm` in `tooling/tree-sitter-plum/queries/plum/` — that's a separate, non-blocking feature (things like "select inside function") rather than what was breaking highlighting. Let me know if you'd like that added too.
+**You:** Yese queries, tags, highlights.scm add all of them as well
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/queries/plum for f in *.scm; do echo "=== $f ==="; cat "$f"; echo; done`
+  - `Write: /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/queries/plum/textobjects.scm`
+**Claude:** Now let's fill in the gaps in `tags.scm` (missing `const` definitions).
+  - `Read: /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/queries/plum/tags.scm`
+  - `Edit: /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/queries/plum/tags.scm`
+**Claude:** Now let's round out `highlights.scm` with the missing operators (`..`, `->`, `=>`, `=`) and the `_` wildcard pattern.
+  - `Read: /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/queries/plum/highlights.scm`
+  - `Edit: /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/queries/plum/highlights.scm`
+**Claude:** Now let's wire `textobjects.scm` into the CLI installer.
+  - `Read: /Users/pyrossh/Code/plum/plum-cli/src/editor.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-cli/src/editor.rs`
+  - `Read: /Users/pyrossh/Code/plum/plum-cli/src/editor.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-cli/src/editor.rs`
+**Claude:** Now let's validate all queries actually compile against the grammar, and rebuild.
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum npx --yes tree-sitter-cli query queries/plum/textobjects.scm --test 2>&1 | head -30 echo "---validate via t`
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum npx --yes tree-sitter-cli query queries/plum/textobjects.scm ../../examples/types.plum 2>&1 echo "---params`
+**Claude:** All working as expected. Let's rebuild the `plum-cli` binary and re-install into the real Helix config to verify the full flow end-to-end.
+  - `Bash: cd /Users/pyrossh/Code/plum && cargo build -p plum-cli 2>&1 | tail -20`
+  - `Bash: /Users/pyrossh/Code/plum/target/debug/plum editor helix echo "---" ls /Users/pyrossh/Code/config/helix/runtime/queries/plum/ echo "---health---" hx --health plu`
+**Claude:** All four checkmarks now — including `Textobject queries: ✓`. The `gotmpl` build failure is that unrelated pre-existing issue, not `plum` (which was already built and skipped). Let's run the full test suite to confirm nothing's broken.
+  - `Bash: cargo test --workspace 2>&1 | tail -40`
+**Claude:** Full suite green. Summary:
+- **Added `tooling/tree-sitter-plum/queries/plum/textobjects.scm`** — `function.around/inside`, `class.around/inside` (covers `type`/`trait`/`enum`), `parameter.around/inside`, `comment.around/inside`. Verified each capture against real examples (`types.plum`, `functions.plum`, `methods.plum`).
+- **Filled gaps in `tags.scm`** — added `const` definitions and `fn_call` references (`reference.call`), which were both missing.
+- **Filled gaps in `highlights.scm`** — the bitwise operators `&`, `|`, `<<`, `>>` and the range operator `..` were never captured (only `...` was); added `->`/`=>` as `@punctuation.special`; added `_` (the wildcard pattern) as `@variable.builtin`.
+- **Wired `textobjects.scm` into the CLI installer** ([plum-cli/src/editor.rs](plum-cli/src/editor.rs)) alongside the other four query files.
+Verified end-to-end against your real Helix config: `hx --health plum` now shows all four green checkmarks (Tree-sitter parser, Highlight queries, Textobject queries, Indent queries) — the last one was the `✘` from before.
+**You:** The helix func receiver type needs to be highlighted as keyword color, right now its type color.
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum npx --yes tree-sitter-cli parse ../../examples/methods.plum 2>&1 | head -20`
+  - `Read: /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/queries/plum/highlights.scm`
+  - `Edit: /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/queries/plum/highlights.scm`
+**Claude:** Let's verify the capture actually resolves to `@keyword` and not `@type` for the receiver position specifically.
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum npx --yes tree-sitter-cli highlight --html --config-path /dev/null ../../examples/methods.plum > /tmp/metho`
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum npx --yes tree-sitter-cli highlight --help 2>&1 | head -20`
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum npx --yes tree-sitter-cli highlight --html -p . --query-paths queries/plum ../../examples/methods.plum 2>/t`
+  - `Bash: cd /Users/pyrossh/Code/plum && cargo build -p plum-cli 2>&1 | tail -10 /Users/pyrossh/Code/plum/target/debug/plum editor helix`
+  - `Bash: grep -A3 "Receiver" /Users/pyrossh/Code/config/helix/runtime/queries/plum/highlights.scm`
+**Claude:** Installed into your real Helix config and confirmed the updated query is live. Reopen a `.plum` file with methods (e.g. `examples/methods.plum`) and the `Cat` in `getAge<Cat>()`/`birthday<Cat>()` should now render in your theme's keyword color instead of the type color.
+Summary of the change ([tooling/tree-sitter-plum/queries/plum/highlights.scm](tooling/tree-sitter-plum/queries/plum/highlights.scm)): the `<Receiver>` annotation is grammatically just a `type` field on `fn` (identical shape to an ordinary field/param type — `type: (type (type_identifier))`), so it was being swept up by the generic `(type_identifier) @type` rule. Added a more specific `(fn type: (type (type_identifier) @keyword))` pattern anchored to `fn` specifically, placed *after* the generic rule — tree-sitter highlighting gives priority to whichever matching pattern appears last in the query file, so this one wins only for the receiver position.
+Verified precisely with `tree-sitter query` against `examples/methods.plum`: the `Cat` in `getAge<Cat>()`/`birthday<Cat>()` now matches both the generic `@type` pattern and the new `@keyword` pattern, while every other `Cat` occurrence (the `type Cat` declaration name, the `inner: Cat` field type, the `-> Cat` return type) matches only `@type` as before — so the change is scoped correctly and doesn't bleed into unrelated type references.
+**You:** Failure 243/246: caddyfile Failed to read directory "/Users/pyrossh/Code/plum/runtime/grammars/sources/caddyfile". Did you use 'hx --grammar fetch'?
+Failure 244/246: clarity Failed to read directory "/Users/pyrossh/Code/plum/runtime/grammars/sources/clarity". Did you use 'hx --grammar fetch'?
+Failure 245/246: rust-format-args Failed to read directory "/Users/pyrossh/Code/plum/runtime/grammars/sources/rust-format-args". Did you use 'hx --grammar fetch'?
+Failure 246/246: plum Parser compilation failed.
+Stdout:
+Stderr: /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/src/scanner.c:62:20: warning: unused function 'set_raw' [-Wunused-function]
+   62 | static inline void set_raw(Delimiter *delimiter) { delimiter->flags |= Raw; }
+      |                    ^~~~~~~
+/Users/pyrossh/Code/plum/tooling/tree-sitter-plum/src/scanner.c:66:20: warning: unused function 'set_bytes' [-Wunused-function]
+   66 | static inline void set_bytes(Delimiter *delimiter) { delimiter->flags |= Bytes; }
+      |                    ^~~~~~~~~
+2 warnings generated.
+ld: open() failed, errno=2 (No such file or directory) for '/Users/pyrossh/Code/plum/runtime/grammars/plum.so'
+clang++: error: linker command failed with exit code 1 (use -v to see invocation)
+Error: 246 grammars failed to build
+`hx --grammar build` exited with exit status: 1; run it manually to compile the Plum grammar
+@pyrossh ➜ plum git(master) $> cargo run --bin plum editor helix
+  - `Bash: cd /tmp && env -i HOME=/Users/pyrossh PATH=/opt/homebrew/bin:/usr/bin:/bin hx --health plum 2>&1 | head -5 echo "---" env -i HOME=/Users/pyrossh PATH=/opt/homeb`
+  - `Bash: echo "$XDG_CONFIG_HOME" ls -la ~/.config/helix 2>&1 echo "---" env -i HOME=/Users/pyrossh PATH=/opt/homebrew/bin:/usr/bin:/bin hx --health hare 2>&1 | head -3`
+  - `Bash: cd /Users/pyrossh/Code/plum env -i HOME=/Users/pyrossh PATH=/opt/homebrew/bin:/usr/bin:/bin hx --grammar build 2>&1 | tail -15`
+  - `Bash: echo "HELIX_RUNTIME=$HELIX_RUNTIME" echo "HELIX_CONFIG_HOME=$HELIX_CONFIG_HOME" env | grep -i helix cat ~/.config/nushell/env.nu 2>/dev/null | grep -i helix cat`
+**Claude:** Let me reproduce this precisely — running `hx --grammar build` from the plum repo root, matching exactly what the user did.
+  - `Bash: cd /Users/pyrossh/Code/plum pwd hx --grammar build 2>&1 | tail -15`
+  - `Bash: which -a hx cargo run --bin plum -- editor helix 2>&1 | tail -20`
+  - `Bash: cd /Users/pyrossh/Code/plum cat > /tmp/print_env.sh << 'EOF' #!/bin/bash echo "CARGO_MANIFEST_DIR=$CARGO_MANIFEST_DIR" echo "CARGO=$CARGO" env | grep -i cargo E`
+**Claude:** Found it — smoking gun confirmed. `cargo run --bin plum` injects `CARGO_MANIFEST_DIR=/Users/pyrossh/Code/plum/plum-cli` into the process environment (not just as a compile-time `env!()` constant), and our `hx` subprocess inherits it. Helix's own runtime-directory resolution apparently treats a present `CARGO_MANIFEST_DIR` as "I'm being run via `cargo run` inside my own dev checkout" and derives `<parent-of-that>/runtime` — which, since it's *our* workspace's manifest dir, resolves to `/Users/pyrossh/Code/plum/runtime` instead of your real Helix config. That's purely an artifact of us spawning `hx` from inside a `cargo run`-invoked process — nothing to do with your shell or config at all.
+  - `Bash: rm -rf /tmp/fakebin /tmp/print_env.sh`
+**Claude:** Let's fix `build_grammar()` to strip Cargo's environment before spawning `hx`.
+  - `Bash: grep -n "fn build_grammar" -A 15 /Users/pyrossh/Code/plum/plum-cli/src/editor.rs`
+  - `Edit: /Users/pyrossh/Code/plum/plum-cli/src/editor.rs`
+**Claude:** Now let's rebuild and verify this actually fixes it via `cargo run`.
+  - `Bash: cd /Users/pyrossh/Code/plum cargo build -p plum-cli 2>&1 | tail -10 echo "=== now via cargo run (matching user's exact invocation) ===" cargo run --bin plum --`
+**Claude:** Fixed — it now correctly resolves to `~/Code/config/helix` (245 already built, only the pre-existing unrelated `gotmpl` failure remains, `plum` built successfully). Let's confirm `plum.so` is intact and run the full test suite.
+  - `Bash: ls -la /Users/pyrossh/Code/config/helix/runtime/grammars/plum.so hx --health plum 2>&1 cargo test -p plum-cli 2>&1 | tail -15`
+**Claude:** **Root cause**: nothing to do with your environment or the grammar itself. When you ran `cargo run --bin plum -- editor helix`, Cargo injected `CARGO_MANIFEST_DIR=/Users/pyrossh/Code/plum/plum-cli` into the process — and our `hx --grammar build` subprocess call inherited it. Helix treats a present `CARGO_MANIFEST_DIR` as a signal that it's Helix's own dev build running under `cargo run`, and resolves its runtime/grammar-output directory relative to that path instead of your actual `~/Code/config/helix` config — hence it tried (and failed) to write `plum.so` into `/Users/pyrossh/Code/plum/runtime/grammars/`, a directory that never existed.
+I confirmed this precisely: captured the real subprocess environment (`CARGO_MANIFEST_DIR` was indeed set), reproduced your exact failure via `cargo run --bin plum -- editor helix`, and confirmed a plain `hx --grammar build` run directly from a shell (no `cargo run` wrapper) never hit this.
+**Fix** ([plum-cli/src/editor.rs](plum-cli/src/editor.rs)): `build_grammar()` now strips every `CARGO*` environment variable before spawning `hx`, so it can't mistake our workspace for its own.
+Verified: rebuilt, reran `cargo run --bin plum -- editor helix` — it now correctly targets `~/Code/config/helix`, builds only the missing `plum` grammar (245 already-built ones untouched), and `hx --health plum` shows all four green checkmarks again. `cargo test -p plum-cli` still passes.
+**You:** This is not fixed?
+The helix func receiver type needs to be highlighted as keyword color, right now its type color.
+Also else if is not colored.
+  - `Bash: grep -n "else" /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/grammar.js echo "---" cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum npx --yes tree-sitte`
+  - `Bash: grep -n "Receiver\|type_identifier) @keyword" /Users/pyrossh/Code/config/helix/runtime/queries/plum/highlights.scm echo "---diff vs repo source---" diff /Users/`
+  - `Bash: mkdir -p ~/.config/tree-sitter cat ~/.config/tree-sitter/config.json 2>/dev/null || echo "NO CONFIG YET"`
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum npx --yes tree-sitter-cli highlight --help 2>&1`
+  - `Bash: cat /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/tree-sitter.json 2>/dev/null`
+**You:** [Request interrupted by user]
+**You:** make build under tree-sitter folder is not working?
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum ls -la Makefile makefile 2>&1 find . -iname "makefile" -maxdepth 2 2>&1`
+  - `Bash: cat /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/Makefile echo "---running make build---" cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum make build 2`
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum ls node_modules/.bin/ 2>&1 | grep -i tree cat package.json 2>/dev/null | head -30 which tree-sitter 2>&1 np`
+**Claude:** The `Makefile` calls the bare `tree-sitter` binary, but it's not installed globally on this machine — we've only ever been invoking it via `npx --yes tree-sitter-cli`. Let's fix the `Makefile` to be self-sufficient.
+  - `Read: /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/Makefile`
+  - `Write: /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/Makefile`
+**Claude:** Let's verify it actually works now.
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum make build 2>&1 | tail -30 echo "---" ls -la grammars/plum.so 2>&1`
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum make corpus_test 2>&1 | tail -15 echo "---gitignore check---" git check-ignore -v grammars/plum.so 2>&1 ||`
+**Claude:** Both `make build` and `make corpus_test` now work, and `grammars/plum.so` is already properly gitignored. This also conveniently gives us a real compiled `.so` to test the highlighting question with — let's continue that investigation now.
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum npx --yes tree-sitter-cli highlight -p . --html ../../examples/methods.plum > /tmp/methods_hl.html 2>/tmp/h`
+**Claude:** Good news on the receiver-type question — I rendered the file through the actual tree-sitter-highlight engine (same conflict-resolution logic Helix embeds) and it's working correctly:
+  - `Bash: grep -A2 "^47:" /tmp/methods_hl.html 2>/dev/null sed -n '47p;55p' /tmp/methods_hl.html`
+**Claude:** That confirms the query logic is correct: the `Cat` in `type Cat =` renders as `#005f5f` (the `@type` color), while the `Cat` in `getAge<Cat>()` renders as `#5f00d7` — the exact same purple as the `type` keyword itself. So the receiver-highlighting fix does work at the query-engine level.
+Now let's fix `else if`, which is a real bug — confirmed it's a single combined token in the grammar, not separate `else`/`if` tokens.
+  - `Read: /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/queries/plum/highlights.scm`
+  - `Edit: /Users/pyrossh/Code/plum/tooling/tree-sitter-plum/queries/plum/highlights.scm`
+**Claude:** Let's verify against the real highlight engine before reinstalling.
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum npx --yes tree-sitter-cli highlight -p . --html ../../examples/control_flow.plum > /tmp/cf_hl.html 2>/tmp/h`
+**Claude:** `else if` now colors correctly (`#5f00d7`, same as `else`/`if`). Let's rebuild the tree-sitter query tests, reinstall into your real Helix config, and run the full workspace suite.
+  - `Bash: cd /Users/pyrossh/Code/plum/tooling/tree-sitter-plum make corpus_test 2>&1 | tail -10 cd /Users/pyrossh/Code/plum cargo build -p plum-cli 2>&1 | tail -5 cargo r`
+**Claude:** Reinstalled — `plum` grammar rebuilt (only one that needed it, unrelated `gotmpl` still pre-existing/unaffected). Let's run the full workspace test suite too.
+  - `Bash: cargo test --workspace 2>&1 | tail -15 hx --health plum 2>&1`
+**Claude:** Both fixed and reinstalled into your real config. Two separate things happened here:
+1. **`else if` — real bug, now fixed.** In the grammar, `"else if"` is literally a single combined token (not `else` followed by `if`), so it never matched the `["if" "else"] @keyword.control.conditional` list. Added `"else if"` to that list, verified against the real tree-sitter-highlight engine (`examples/control_flow.plum` — both now render in the same conditional-keyword color).
+2. **Receiver-type highlighting — the query is actually correct, not broken.** I rendered `examples/methods.plum` through the real tree-sitter-highlight engine (the same core library Helix embeds) and confirmed: the `Cat` in `type Cat =` gets `#005f5f` (the `@type` color), while the `Cat` in `getAge<Cat>()` gets `#5f00d7` — the *exact same purple* as the `type` keyword itself. So the override is winning correctly at the query-resolution level.
+If it's still showing as type-color in your actual running Helix session, that's very likely a **stale cache** — Helix compiles and caches the query set once per running instance, and picks up `highlights.scm` changes only on a full restart, not just closing/reopening the buffer or `:reload`. Fully quit Helix and reopen it (not just the file) and it should show correctly now — let me know if it still doesn't after that, since I'd want to dig further rather than assume.
+Also fixed along the way: `tooling/tree-sitter-plum/Makefile`'s `make build`/`make corpus_test` called a bare `tree-sitter` binary that isn't installed globally on this machine — updated it to use `npx --yes tree-sitter-cli`, verified both targets now work and produce `grammars/plum.so`.

plum-cli/src/editor.rs CHANGED Viewed

@@ -41,6 +41,8 @@ const HELIX_INJECTIONS: &str =
     include_str!("../../tooling/tree-sitter-plum/queries/plum/injections.scm");
 const HELIX_TAGS: &str =
     include_str!("../../tooling/tree-sitter-plum/queries/plum/tags.scm");
+const HELIX_TEXTOBJECTS: &str =
+    include_str!("../../tooling/tree-sitter-plum/queries/plum/textobjects.scm");
 /// The absolute path to the `tree-sitter-plum` grammar crate on the machine that
 /// *built* this `plum` binary. Baked in at compile time so a contributor running
@@ -98,6 +100,7 @@ fn install_helix() -> Result<()> {
     fs::write(queries_dir.join("indents.scm"), HELIX_INDENTS)?;
     fs::write(queries_dir.join("injections.scm"), HELIX_INJECTIONS)?;
     fs::write(queries_dir.join("tags.scm"), HELIX_TAGS)?;
+    fs::write(queries_dir.join("textobjects.scm"), HELIX_TEXTOBJECTS)?;
     println!("installed Plum support for Helix in {}", config_dir.display());
@@ -112,7 +115,25 @@ fn install_helix() -> Result<()> {
 }
 fn build_grammar() {
+    let mut cmd = std::process::Command::new("hx");
-    match std::process::Command::new("hx").arg("--grammar").arg("build").status() {
+    cmd.arg("--grammar").arg("build");
+    // When `plum` itself is run via `cargo run`/`cargo test`, Cargo sets
+    // CARGO_MANIFEST_DIR (and friends) in *this* process's environment, and a
+    // plain `Command` inherits it into the `hx` child. Helix's own runtime-dir
+    // resolution treats a present CARGO_MANIFEST_DIR as "I'm Helix's own dev
+    // build running under cargo", and resolves grammar output relative to
+    // *our* workspace root instead of the user's real Helix config — so `hx`
+    // silently tries to write the compiled grammar to `<plum repo>/runtime/`
+    // rather than `~/.config/helix/runtime/`. Strip every CARGO_* var so `hx`
+    // falls back to its normal (non-dev) config/runtime-dir resolution.
+    for (key, _) in env::vars() {
+        if key.starts_with("CARGO") {
+            cmd.env_remove(key);
+        }
+    }
+    match cmd.status() {
         Ok(status) if status.success() => {
             println!("compiled the Plum tree-sitter grammar (hx --grammar build)");
         }

tooling/tree-sitter-plum/Makefile CHANGED Viewed

@@ -1,7 +1,9 @@
+TREE_SITTER := npx --yes tree-sitter-cli
 build:
-		tree-sitter generate
+		$(TREE_SITTER) generate
-		tree-sitter build -o grammars/plum.so
+		$(TREE_SITTER) build -o grammars/plum.so
 corpus_test:
-		tree-sitter generate
+		$(TREE_SITTER) generate
-		tree-sitter test
+		$(TREE_SITTER) test

tooling/tree-sitter-plum/queries/plum/highlights.scm CHANGED Viewed

@@ -44,6 +44,10 @@
   "/"
   "%"
   "^"
+  "&"
+  "|"
+  "<<"
+  ">>"
   "-"
   "+"
   ">"
@@ -53,9 +57,17 @@
   "<>"
   "||"
   "&&"
+  ".."
   "..."
 ] @operator
+[
+  "->"
+  "=>"
+] @punctuation.special
+"_" @variable.builtin
 [
   "import"
   "module"
@@ -73,6 +85,7 @@
 [
   "if"
   "else"
+  "else if"
 ] @keyword.control.conditional
 [
@@ -84,4 +97,15 @@
 (todo) @keyword.control.exception
-"match" @keyword
+"match" @keyword
+; `name<Receiver>(...)` — the `<Receiver>` method annotation is grammatically a
+; `type` field on `fn` (same shape as an ordinary field/param type), but
+; semantically it's the method's receiver, not a type reference — highlight it
+; like the `self` it implicitly binds rather than like `@type`. This pattern is
+; listed after the generic `(type_identifier) @type` above so it wins: when a
+; node matches more than one pattern, tree-sitter highlighting gives priority
+; to whichever pattern appears last in the query file.
+(fn
+  type: (type
+    (type_identifier) @keyword))

tooling/tree-sitter-plum/queries/plum/tags.scm CHANGED Viewed

@@ -9,3 +9,12 @@
 (fn
   name: (fn_identifier) @name) @definition.function
+(const
+  (const_identifier) @name) @definition.constant
+(fn_call
+  function: (var_identifier) @name) @reference.call
+(fn_call
+  function: (type_identifier) @name) @reference.call

tooling/tree-sitter-plum/queries/plum/textobjects.scm ADDED Viewed

@@ -0,0 +1,17 @@
+(fn
+  body: (_) @function.inside) @function.around
+(class
+  fields: (field) @class.inside) @class.around
+(trait
+  fields: (field) @class.inside) @class.around
+(enum
+  (field) @class.inside) @class.around
+(param) @parameter.inside
+(param) @parameter.around
+(comment) @comment.inside
+(comment) @comment.around