Tree-sitter support for SuperCollider

madskjeldgaard · October 25, 2022, 12:43pm

If you are able to make TS crash reproducibly with any class code, please post it here so we can investigate further. This is very interesting!

john-d-murphy · October 25, 2022, 12:44pm

Will do - I’m hoping it’s just bc I’m using old code.

madskjeldgaard · October 25, 2022, 12:45pm

Make sure you are running tree-sitter version 0.20.7. I suspect this release fixed the segfaults

Paum3 · December 18, 2024, 11:33am

Hi @dyalan.
Thanks for you long and detailed notes about setting the beast up on emacs. Thanks to this I’ve running tree-sitter on my archlinux.
Just to add something, as for now this line is not recognized as correct (at least for my box)
(add-to-list 'tree-sitter-major-mode-language-alist '(sclang-mode . supercollider))

Instead of this, I’ve added:

(after! tree-sitter
  (add-to-list 'tree-sitter-major-mode-language-alist
               '(sclang-mode . supercollider)))

(use-package! tree-sitter-langs
  :after tree-sitter
  :config
  ;; Ensure SuperCollider grammar is loaded
  (tree-sitter-require 'supercollider))

Did you make some new functionality for sclang in emacs with tree-siiter? Would you give me some clue, what it is good for?
best

madskjeldgaard · September 3, 2025, 7:27pm

Hi all.

Happy to announce that tree-sitter-supercollider has gotten some serious love recently and is now even more robust. A lot of work by bsssssss, thanks!

tree-sitter-supercollider is now able to parse almost anything from SuperCollider syntax (that said, I keep discovering new esoteric syntax goodies (see issues)).

dgk · September 18, 2025, 8:16pm

For those using sclang-mode in Emacs 29.1 and above, here is an experimetal (especially the indentation) sclang-ts-mode implementing tree-sitter grammar based syntax highlighting (fontification) and indentation.

Many thanks to Mads K and the contributors!

Any feedback is very welcome!

smoge · September 21, 2025, 6:13pm

Hey yo,

I’ve been hacking the ts grammar and opened this:

github.com/madskjeldgaard/tree-sitter-supercollider

Fix method-call precedence and flatten binary operators in grammar

madskjeldgaard:main ← smoge:fix/flat-binops-postfix-binding

opened 11:15AM - 20 Sep 25 UTC

smoge

+379 -245

## Fix method-call precedence, unify binary operators, and implement list compre…hensions ### Summary - **Operators:** All binary operators now use consistent left-to-right evaluation - **Method chains bind tightly:** New `_primary`/`_postfix` rules ensure method calls attach to the right expression - **List comprehensions:** Full support for `{:` syntax with generators, guards, bindings, side effects, and termination - **Fixed named arguments:** `parameter: value` syntax now correctly stores values - **Control flow:** `if`, `while`, `switch` handle expressions consistently - **Block syntax:** Code blocks use `{ … }`, parentheses use `( … )` - **Keyword messages:** Separated from binary operators into dedicated rule for `[1,2,3] collect: {...}` syntax ### Motivation Problems fixed: - No support for list comprehensions (`{: x*2, x <- (1..10)}`) - `identifier:` patterns conflated with binary operators - `{ … }` and `(…)` confusion - `.midiratio` binding to entire expressions instead of grouped RHS - `curve: -1` stored incorrectly under `name:` instead of `value:` - Operator precedence tiers that don't exist in sclang ### Commit structure and key changes This PR is organized into 15 commits: 1. Introduce block/group distinction (1) 2. Add _primary/_postfix hierarchy (2-3) 3. Flatten binary precedence (4-6) 4. Fix argument handling (7) 5. Update control structures (10) 6. Clean up unused code (8-9, 11-13) 7. Add keyword messages (14-15) 8. Add list comprehensions (15-16) ### List comprehensions List comprehension syntax: ```supercollider {: body, qualifier, qualifier, ... } ``` Supported qualifiers: - **Generators:** `x <- (1..10)` - **Guards:** `x.odd` - **Variable bindings:** `var z = x*x` - **Side effects:** `:: x.postln` - **Termination:** `:while x < 100` ### Keyword messages Separated `identifier:` patterns from binary operators: ```javascript keyword_message: $ => prec.left(PRECEDENCE.keyword_message, seq( field('receiver', $._postfix), field('selector', alias(/[a-zA-Z_]\w*:/, $.keyword_selector)), field('argument', $._postfix) )) ``` This handles `[1,2,3] select: {|x| x > 1}` as a distinct syntactic form. ### Blocks & grouping - `code_block: '{' parameter_list? expression_sequence? '}'` - `group: '(' expression ')'` - `function_block` now uses `code_block` directly ### Chains > binops - Introduce `_primary` (atoms) and `_postfix` (primary + chain) - Method chains parse left-associatively with high `CALL` precedence - `function_call` receivers restricted to `_primary` ### Flat binary operators (left-to-right) All symbolic binary operators now share one `BIN` tier: ```javascript binary_expression: $ => prec.left(PRECEDENCE.BIN, seq( field('left', $._postfix), field('operator', choice( '||','&&','|','^','&','==','!=','<','<=','>','>=', '<<','>>','+','-','++','+/+','*','/','%','**' )), field('right', $._postfix) )) ``` ### Arguments - Drop `argument_calls`/`unnamed_argument` - `named_argument: name ':' value` with RHS under `value:` ### Control structures - `if`, `while`, `switch` expressions take `_postfix` (chains bind) ## Before / After ### List comprehensions - **Before:** Not supported - **After:** Supported ```supercollider {: [x,y], x <- (1..5), y <- (1..x), (x+y).isPrime } ``` ### Keyword messages - Dedicated AST node with receiver/selector/argument fields ### `.midiratio` binding - **Before:** Could attach to `\freq.kr(440) * (…)` as a whole - **After:** Attaches to grouped RHS term: ``` \freq.kr(440) * (Env.perc(...).ar * 48).midiratio └────── group ────────┘└postfix┘ ``` ### Named argument - **Before:** `curve: -1` created two `name:` fields - **After:** `name: curve`, `value: -1` ## Testing Needs tests for: - List comprehension qualifiers - Keyword message vs binary operator disambiguation - Postfix vs group binding - Named args with negative values - Left-to-right operator evaluation ## Breaking changes - AST structure changes for keyword messages (now distinct from `binary_expression`) - List comprehensions add new node types - No breaking changes expected for valid sclang code parsing

Some changes:

makes method chains bind before any binary operator via _primary → _postfix
adds List Comprehensions
flattens all binary operators into one left-to-right precedence rule (which matches sclang)
fixes named arguments (name: value)
differentiates { … } code blocks and ( … ) groups

Currently, the branch has 16 small commits, making it easy to review changes incrementally.

smoge · October 7, 2025, 6:04am

Sharing a few more suggestions, this time also for scanner.c, to enhance clarity and speed. The scanner now handles low-level details within Treesitter’s grammar.

For instance, I’ve replaced conditionals and regular expression checks with lookup tables for whitespace and operators, enabling sort speed to be constant. The updated scanner effectively manages nested /* ... */ comments, maintaining comment depth and allowing graceful recovery from unclosed comments.

Additionally, a state machine is implemented to identify operators such as ++ and ->, as well as pattern-matching operators of 1 to 3 characters, rather than relying on string comparisons. It is faster and more convenient, since it can infer even new operators. The scanner utilizes a compact state representation (only two bytes) to track comment depth and array depth, enabling even smoother incremental parsing.

The code ended up being around 200 lines shorter. Glad to receive feedback, this is still experimental.

github.com/madskjeldgaard/tree-sitter-supercollider

scanner handles context-sensitive tasks that need state tracking (experimental)

madskjeldgaard:main ← smoge:scanner-context-for-grammar

opened 12:40AM - 07 Oct 25 UTC

smoge

+842 -1006

I'm excited to share the recent changes made to `scanner.c` that enhance clarity… and speed. I've replaced conditionals and regular expression checks with lookup tables for whitespace and operators, enabling sort speed to be constant. The updated scanner effectively manages nested `/* ... */` comments, maintaining comment depth and allowing graceful recovery from unclosed comments, which enhances stability with incomplete input. Also implemented a state machine for identifying operators (from1 to 3 characters), such as `++` and `->`, replacing string comparisons. This change improves precision, speeds up, and eliminates backtracking errors. The scanner utilizes minimal state (only two bytes) to track comment depth and hash array depth, enabling incremental parsing without requiring re-parsing of entire files after edits. Also ensured the scanner checks the `valid_symbols[]` list before emitting tokens. --- ## Scanner (`scanner.c`) Handles lexical non-trivial stuff / context-sensitive tokens: * Nested block comments * List comprehensions `{:` * Literal arrays `#[ ]` * Symbolic operators (1–3 chars) ### Tokens 1. **`BLOCK_COMMENT`** — recognizes nested `/* … */` 2. **`LIST_COMP_OPEN`** — matches `{:` as a single token. 3. **`HASH_OPEN` / `HASH_CLOSE`** — mark entry/exit of literal arrays; handle nested `#[`. 4. **`SYMBOL_IN_HASH`** — bare identifiers in `#[ ]` become symbols. 5. **`OP_SYM`** — longest-match operators (`@|@`, `<<*`, `+>>`, etc.); excludes `=` to avoid conflict with assignment. --- ## improvement (experimental) * handling of nested constructs and symbolic operators. * No ambiguity between block `{}` and comprehension `{:`. * Correct treatment of bare symbols in literal arrays. * Operators recognition in `scanner.c`

Lilith93 · November 26, 2025, 9:19pm

When cloning the repo I’m asked for a password:

 git clone https://github.com/supercollider/tree-sitter-supercollider.git
Klone nach 'tree-sitter-supercollider' …
Username for 'https://github.com':

Cloning other repos works fine without any password.

madskjeldgaard · November 26, 2025, 9:48pm

You need to use ssh, I think