tree-sitter-ucode 0.3.0 → 0.5.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.3.0",
+  "version": "0.5.0",
   "description": "Ucode grammar for tree-sitter",
   "repository": {
     "type": "git",
@@ -24,9 +24,13 @@
     "bindings/node/*",
     "queries/*",
     "src/**",
-    "tmpl/grammar.js",
-    "tmpl/src/**",
-    "tmpl/queries/*",
+    "markup/grammar.js",
+    "markup/src/**",
+    "markup/queries/*",
+    "scripts/generate-markup-grammar.js",
+    "ucdocs/grammar.js",
+    "ucdocs/src/**",
+    "ucdocs/queries/*",
     "*.wasm"
   ],
   "dependencies": {
@@ -47,7 +51,7 @@
   },
   "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",
+    "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/locals.scm

@@ -5,6 +5,7 @@
 ; Scopes
 ; -------------------------------------------------------------------------
 
+(program) @local.scope
 (function_declaration) @local.scope
 (function_expression) @local.scope
 (arrow_function) @local.scope
@@ -24,6 +25,13 @@
 
 ; Function declaration names belong to the enclosing scope so that
 ; callers outside the function body can resolve them.
+;
+; NOTE: tree-sitter does not evaluate #set! predicates — it has no built-in
+; concept of "place this definition one scope level up." This annotation is
+; metadata only; the consumer must detect it (predicate name and args) and
+; implement the scope-parent walk itself. A consumer that builds a
+; scope -> definitions map by structural nesting alone will misplace this
+; definition: it will end up invisible to callers outside the function body.
 (function_declaration
   name: (identifier) @local.definition.function
   (#set! definition.function.scope parent))

package/queries/tags.scm

@@ -1,5 +1,19 @@
 ; Tags queries for ucode.
 ; Used by GitHub code navigation and tools that index symbol definitions.
+;
+; NOTE on #strip! and #select-adjacent!: these are non-standard predicates with
+; no tree-sitter runtime support — tree-sitter only evaluates #eq?/#match?/
+; #not-match?-family predicates and filters non-matching captures; everything
+; else (including these two) passes through as metadata for the consumer to
+; act on. A consumer that reads @doc captures verbatim gets raw `/** ... */`
+; text with leading `*` characters intact (no #strip!), and may associate a
+; comment from several lines above with the wrong definition (no
+; #select-adjacent!). Expected semantics:
+;   #strip! @capture <regex>        — strip text matching <regex> from the
+;                                      start/end of @capture's text.
+;   #select-adjacent! @a @b         — only keep this match if @a is on a line
+;                                      immediately preceding @b (no blank
+;                                      lines or other statements between).
 
 ; -------------------------------------------------------------------------
 ; Function definitions — named declarations (brace body or endfunction body)
@@ -87,5 +101,4 @@
 
 (call_expression
   function: (member_expression
-    property: (property_identifier) @name)
-  arguments: (_) @reference.call)
+    property: (property_identifier) @name)) @reference.call

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)}`);