tree-sitter-ucode 0.2.0 → 0.4.0

package/markup/src/scanner.c

@@ -0,0 +1,22 @@
+/*
+ * External scanner for the ucode_markup grammar.
+ *
+ * All implementation lives in src/scanner_impl.h (static functions).  This
+ * file only exports the five tree_sitter_ucode_markup_external_scanner_*
+ * entry points — no ucode_* symbols leak into this shared library.
+ */
+
+#include "../../src/scanner_impl.h"
+
+void *tree_sitter_ucode_markup_external_scanner_create(void) { return NULL; }
+void  tree_sitter_ucode_markup_external_scanner_destroy(void *p) { (void)p; }
+unsigned tree_sitter_ucode_markup_external_scanner_serialize(void *p, char *b) { (void)p; (void)b; return 0; }
+void  tree_sitter_ucode_markup_external_scanner_deserialize(void *p, const char *b, unsigned n) {
+    (void)p; (void)b; (void)n;
+}
+
+bool tree_sitter_ucode_markup_external_scanner_scan(
+    void *payload, TSLexer *lexer, const bool *valid_symbols
+) {
+    return ucode_scanner_scan(payload, lexer, valid_symbols);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tree-sitter-ucode",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Ucode grammar for tree-sitter",
   "repository": {
     "type": "git",
@@ -24,9 +24,10 @@
     "bindings/node/*",
     "queries/*",
     "src/**",
-    "tmpl/grammar.js",
-    "tmpl/src/**",
-    "tmpl/queries/*",
+    "markup/grammar.js",
+    "markup/src/**",
+    "markup/queries/*",
+    "scripts/generate-markup-grammar.js",
     "*.wasm"
   ],
   "dependencies": {
@@ -35,7 +36,7 @@
   },
   "devDependencies": {
     "prebuildify": "^6.0.1",
-    "tree-sitter-cli": "^0.26.0"
+    "tree-sitter-cli": "0.26.9"
   },
   "peerDependencies": {
     "tree-sitter": "^0.22.0"
@@ -47,8 +48,8 @@
   },
   "scripts": {
     "install": "node-gyp-build",
-    "build": "tree-sitter generate && tree-sitter generate tmpl/grammar.js --output tmpl/src && node-gyp-build && tree-sitter build --output ucode.so . && tree-sitter build --output ucode_tmpl.so ./tmpl",
-    "test": "tree-sitter test && tree-sitter test -p tmpl",
+    "build": "node scripts/generate-markup-grammar.js && tree-sitter generate && tree-sitter generate markup/grammar.js --output markup/src && node-gyp-build && tree-sitter build --output ucode.so . && tree-sitter build --output ucode_markup.so ./markup",
+    "test": "node scripts/run-tests.js",
     "prestart": "tree-sitter build --wasm",
     "start": "tree-sitter playground"
   }

package/queries/folds.scm

@@ -0,0 +1,38 @@
+; Fold queries for ucode.
+; Each captured node becomes a collapsible fold region.
+
+; -------------------------------------------------------------------------
+; Brace-delimited blocks
+;
+; statement_block covers brace-body function_declaration, function_expression,
+; and arrow_function bodies — the signature line stays visible because the
+; fold starts at '{', not at the 'function' keyword.
+; -------------------------------------------------------------------------
+
+[
+  (statement_block)
+  (switch_body)
+  (object)
+  (array)
+] @fold
+
+; -------------------------------------------------------------------------
+; Alternative (colon/endif) syntax — fold the entire construct
+; -------------------------------------------------------------------------
+
+[
+  (if_alt_statement)
+  (for_alt_statement)
+  (for_in_alt_statement)
+  (while_alt_statement)
+] @fold
+
+; -------------------------------------------------------------------------
+; Colon-body function declaration (function f(): ... endfunction)
+;
+; Brace-body function declarations are folded via (statement_block) above.
+; The colon form has no statement_block, so we fold the whole declaration.
+; We filter on "endfunction" so this pattern only matches the colon form.
+; -------------------------------------------------------------------------
+
+(function_declaration "endfunction") @fold

package/queries/highlights.scm

@@ -119,6 +119,12 @@
 ["import" "export"] @keyword.import
 ["as" "from"] @keyword.import
 
+; 'default' in export context is a module keyword, not a conditional.
+; These patterns are more specific than the generic ["switch" "case" "default"]
+; below, so they take priority for 'default' tokens inside export constructs.
+(export_statement "default" @keyword.import)
+(export_specifier "default" @keyword.import)
+
 ; -------------------------------------------------------------------------
 ; Keywords — storage / operators
 ; -------------------------------------------------------------------------

package/queries/indents.scm

@@ -0,0 +1,63 @@
+; Indentation queries for ucode.
+; Capture names follow the nvim-treesitter standard.
+
+; -------------------------------------------------------------------------
+; Brace-delimited constructs — increase indent inside
+; -------------------------------------------------------------------------
+
+[
+  (statement_block)
+  (switch_body)
+  (object)
+  (array)
+  (arguments)
+  (formal_parameters)
+] @indent.begin
+
+; Closing delimiters — decrease indent
+[
+  "}"
+  "]"
+  ")"
+] @indent.end
+
+; -------------------------------------------------------------------------
+; Alternative (colon/endif) syntax
+; -------------------------------------------------------------------------
+
+; The ':' after the condition opens the body
+(if_alt_statement ":" @indent.begin)
+(elif_clause ":" @indent.begin)
+(for_alt_statement ":" @indent.begin)
+(for_in_alt_statement ":" @indent.begin)
+(while_alt_statement ":" @indent.begin)
+(function_declaration ":" @indent.begin)
+
+; Closing keywords close the body
+[
+  "endif"
+  "endfor"
+  "endwhile"
+  "endfunction"
+] @indent.end
+
+; -------------------------------------------------------------------------
+; Branch keywords (else/elif) — dedent keyword, indent following body
+; -------------------------------------------------------------------------
+
+(else_clause "else") @indent.branch
+(else_alt_clause "else") @indent.branch
+(elif_clause "elif") @indent.branch
+
+; else_alt_clause has no ':' delimiter (grammar: 'else' repeat(statement)),
+; so @indent.branch alone only dedents the 'else' keyword — it does not
+; open an indent scope for the body. Add @indent.begin on the whole node
+; so the body statements are indented one level relative to 'else'.
+(else_alt_clause) @indent.begin
+
+; -------------------------------------------------------------------------
+; Switch
+; -------------------------------------------------------------------------
+
+(switch_case "case") @indent.branch
+(switch_default "default") @indent.branch

package/queries/locals.scm

@@ -5,6 +5,7 @@
 ; Scopes
 ; -------------------------------------------------------------------------
 
+(program) @local.scope
 (function_declaration) @local.scope
 (function_expression) @local.scope
 (arrow_function) @local.scope

package/queries/textobjects.scm

@@ -0,0 +1,84 @@
+; Text-object queries for nvim-treesitter-textobjects.
+; Provides @function, @parameter, @conditional, @loop, @call, and @block
+; text objects for ucode source files.
+
+; -------------------------------------------------------------------------
+; Functions
+; -------------------------------------------------------------------------
+
+; Brace-body function declaration
+(function_declaration
+  body: (statement_block) @function.inner) @function.outer
+
+; Colon-body function declaration — outer only; no block node to target for inner
+(function_declaration "endfunction") @function.outer
+
+(function_expression
+  body: (statement_block) @function.inner) @function.outer
+
+(arrow_function
+  body: (statement_block) @function.inner) @function.outer
+
+; Arrow function with expression body (no braces).
+; Uses the 'expression' supertype so all expression forms are matched
+; without an explicit enumeration — including update_expression (x => x++),
+; assignment_expression (x => y = 1), and any type added to the grammar later.
+(arrow_function
+  body: (expression) @function.inner) @function.outer
+
+; -------------------------------------------------------------------------
+; Parameters
+;
+; @parameter.inner — the parameter node itself
+; @parameter.outer — same node; nvim-treesitter-textobjects extends the
+;   selection to absorb adjacent ',' delimiters automatically when the
+;   capture name ends in .outer
+; -------------------------------------------------------------------------
+
+(formal_parameters (_) @parameter.inner)
+(formal_parameters (_) @parameter.outer)
+
+; -------------------------------------------------------------------------
+; Conditionals
+; -------------------------------------------------------------------------
+
+(if_statement
+  consequence: (statement_block) @conditional.inner) @conditional.outer
+
+(if_alt_statement) @conditional.outer
+
+; -------------------------------------------------------------------------
+; Loops
+; -------------------------------------------------------------------------
+
+(for_statement
+  body: (statement_block) @loop.inner) @loop.outer
+
+(for_in_statement
+  body: (statement_block) @loop.inner) @loop.outer
+
+(while_statement
+  body: (statement_block) @loop.inner) @loop.outer
+
+(for_alt_statement) @loop.outer
+(for_in_alt_statement) @loop.outer
+(while_alt_statement) @loop.outer
+
+; -------------------------------------------------------------------------
+; Calls
+; -------------------------------------------------------------------------
+
+(call_expression
+  arguments: (arguments) @call.inner) @call.outer
+
+; -------------------------------------------------------------------------
+; Blocks
+;
+; @block.outer — the full statement_block including braces
+; @block.inner — named children only; nvim-treesitter-textobjects selects
+;   from the first to the last captured child, covering the block interior
+;   without needing the deprecated #make-range! predicate
+; -------------------------------------------------------------------------
+
+(statement_block) @block.outer
+(statement_block (_) @block.inner)

package/scripts/generate-markup-grammar.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+/**
+ * Generate markup/grammar.js from grammar.js.
+ *
+ * The main grammar has `program` as the first (start) rule so that `.uc`
+ * files work.  For `.uc.tmpl` files we need `markup` to be the
+ * start rule.  This script produces markup/grammar.js by:
+ *
+ *   1. Changing the grammar name from 'ucode' to 'ucode_markup'
+ *   2. Swapping the `markup` and `program` rule definitions so `markup`
+ *      appears first (tree-sitter uses the first rule as the start rule)
+ *
+ * The generated file is checked in and rebuilt whenever grammar.js changes.
+ * Run via `npm run generate-markup` or as part of `npm run build`.
+ */
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const srcPath = path.resolve(__dirname, '..', 'grammar.js');
+const dstPath = path.resolve(__dirname, '..', 'markup', 'grammar.js');
+
+let src = fs.readFileSync(srcPath, 'utf8');
+
+// 1. Rename the grammar
+src = src.replace(/name:\s*'ucode'/, "name: 'ucode_markup'");
+
+// 2. Locate the `program` and `markup` rule definitions inside `rules: { ... }`.
+//    Each top-level rule starts with "\n    <ident>: $ =>".
+//    We need to swap the two so `markup` comes first.
+
+// Find the position of each rule's leading newline+spaces
+const programMatch = src.match(/\n    program: \$/);
+const markupMatch  = src.match(/\n    markup: \$/);
+
+if (!programMatch || !markupMatch) {
+    console.error('Could not locate program or markup rule in grammar.js');
+    process.exit(1);
+}
+
+const programIdx = src.indexOf('\n    program: $');
+const markupIdx  = src.indexOf('\n    markup: $');
+
+if (programIdx === markupIdx) {
+    console.error('program and markup are at the same position?');
+    process.exit(1);
+}
+
+// Determine which comes first in the file
+const firstIdx  = Math.min(programIdx, markupIdx);
+const secondIdx = Math.max(programIdx, markupIdx);
+
+// Extract each rule: from its start up to the start of the next rule (or end-of-rules).
+// A top-level rule starts at "\n    <ident>: $" and ends just before the next "\n    <ident>: $".
+// We need the SPANS of the two rules to swap them.
+
+function findNextRuleStart(text, from) {
+    // Match "\n    <word>: $ =>" — the arrow function syntax uniquely identifies
+    // rule definitions vs. object properties at the same indentation level.
+    const re = /\n    \w+: \$ =>/g;
+    re.lastIndex = from + 1;     // skip the current match
+    const m = re.exec(text);
+    return m ? m.index : text.length;
+}
+
+const firstEnd  = findNextRuleStart(src, firstIdx);
+const secondEnd = findNextRuleStart(src, secondIdx);
+
+const firstRule  = src.slice(firstIdx,  firstEnd);
+const secondRule = src.slice(secondIdx, secondEnd);
+
+// Reconstruct: everything before firstIdx, then the rule that was second,
+// then everything between the two rules, then the rule that was first,
+// then everything after secondEnd.
+const between = src.slice(firstEnd, secondIdx);
+
+const swapped =
+    src.slice(0, firstIdx) +
+    secondRule +
+    between +
+    firstRule +
+    src.slice(secondEnd);
+
+// 3. Add a header comment noting this is generated
+const header = '// GENERATED by scripts/generate-markup-grammar.js — do not edit by hand.\n';
+const output = header + swapped;
+
+fs.mkdirSync(path.dirname(dstPath), { recursive: true });
+fs.writeFileSync(dstPath, output, 'utf8');
+
+console.log(`Wrote ${path.relative(process.cwd(), dstPath)}`);