tree-sitter-ucode 0.3.0 → 0.4.0

package/src/scanner_impl.h

@@ -0,0 +1,494 @@
+/*
+ * Shared external-scanner implementation for ucode and ucode_markup.
+ *
+ * Included by src/scanner.c and markup/src/scanner.c.  Every function here
+ * is static so each compilation unit gets its own copy and no ucode_*
+ * symbols leak into the markup shared library.
+ *
+ * Token order MUST match the `externals` array in grammar.js:
+ *   0  AUTOMATIC_SEMICOLON        $._automatic_semicolon
+ *   1  TEMPLATE_CHARS             $._template_chars
+ *   2  TERNARY_QMARK              $._ternary_qmark
+ *   3  RAW_TEXT                   $.raw_text
+ *   4  STATEMENT_TAG_OPEN         $.statement_tag_open         {%
+ *   5  STATEMENT_TAG_TRIM_OPEN    $.statement_tag_trim_open    {%-
+ *   6  STATEMENT_TAG_LSTRIP_OPEN  $.statement_tag_lstrip_open  {%+
+ *   7  STATEMENT_TAG_CLOSE        $.statement_tag_close        %}
+ *   8  STATEMENT_TAG_TRIM_CLOSE   $.statement_tag_trim_close   -%}
+ *   9  EXPRESSION_TAG_OPEN        $.expression_tag_open        {{
+ *  10  EXPRESSION_TAG_TRIM_OPEN   $.expression_tag_trim_open   {{-
+ *  11  EXPRESSION_TAG_CLOSE       $.expression_tag_close       }}
+ *  12  EXPRESSION_TAG_TRIM_CLOSE  $.expression_tag_trim_close  -}}
+ */
+
+#ifndef UCODE_SCANNER_IMPL_H_
+#define UCODE_SCANNER_IMPL_H_
+
+#include "tree_sitter/parser.h"
+#include <wctype.h>
+
+enum TokenType {
+    AUTOMATIC_SEMICOLON,
+    TEMPLATE_CHARS,
+    TERNARY_QMARK,
+    RAW_TEXT,
+    STATEMENT_TAG_OPEN,
+    STATEMENT_TAG_TRIM_OPEN,
+    STATEMENT_TAG_LSTRIP_OPEN,
+    STATEMENT_TAG_CLOSE,
+    STATEMENT_TAG_TRIM_CLOSE,
+    EXPRESSION_TAG_OPEN,
+    EXPRESSION_TAG_TRIM_OPEN,
+    EXPRESSION_TAG_CLOSE,
+    EXPRESSION_TAG_TRIM_CLOSE,
+};
+
+static inline void advance(TSLexer *lexer) { lexer->advance(lexer, false); }
+static inline void skip(TSLexer *lexer)    { lexer->advance(lexer, true);  }
+
+/* -------------------------------------------------------------------------
+ * Markup-mode tokens
+ * ---------------------------------------------------------------------- */
+
+/*
+ * scan_raw_text_from(lexer, has_content)
+ *
+ * Core raw-text loop.  Caller sets has_content=true when it has already
+ * consumed one or more characters (e.g. a lone '{' that turned out not to
+ * be a tag opener) so that the scanner returns true even if no additional
+ * characters follow.
+ *
+ * Stops BEFORE '{' that is followed by '%', '{', or '#' (tag/comment openers).
+ * A lone '{' is committed on the next iteration's mark_end.
+ */
+static bool scan_raw_text_from(TSLexer *lexer, bool has_content) {
+    lexer->result_symbol = RAW_TEXT;
+    while (true) {
+        lexer->mark_end(lexer);
+        if (lexer->lookahead == '\0') return has_content;
+        if (lexer->lookahead == '{') {
+            advance(lexer);
+            if (lexer->lookahead == '%' ||
+                lexer->lookahead == '{' ||
+                lexer->lookahead == '#')
+                return has_content;
+        } else {
+            advance(lexer);
+        }
+        has_content = true;
+    }
+}
+
+/*
+ * scan_markup(lexer, valid_symbols)
+ *
+ * Unified handler for all three markup-opener tokens (RAW_TEXT,
+ * STATEMENT_TAG_OPEN, EXPRESSION_TAG_OPEN).  Must be called when at
+ * least one of those three is valid.
+ *
+ * Problem with calling separate sub-scanners sequentially:
+ *   scan_raw_text advances past '{' when it returns false (tag found),
+ *   leaving the lexer at position+1.  Subsequent sub-scanners then see
+ *   the wrong character and also fail, so the whole scanner returns false
+ *   and tree-sitter falls back to the internal '{' token — which has no
+ *   valid action in the markup root state and triggers error recovery.
+ *
+ * Fix: handle '{' atomically here.  Advance past '{' exactly once, inspect
+ * the second character, then dispatch without any further position skew.
+ */
+static bool scan_markup(TSLexer *lexer, const bool *valid_symbols) {
+    /* Not at '{': only raw text is possible. */
+    if (lexer->lookahead != '{')
+        return valid_symbols[RAW_TEXT] ? scan_raw_text_from(lexer, false) : false;
+
+    /* Peek at the second character by advancing past '{'. */
+    advance(lexer);
+
+    /* {%  {%-  {%+ — statement tag open (emit the precise variant) */
+    if (lexer->lookahead == '%' &&
+        (valid_symbols[STATEMENT_TAG_OPEN] ||
+         valid_symbols[STATEMENT_TAG_TRIM_OPEN] ||
+         valid_symbols[STATEMENT_TAG_LSTRIP_OPEN])) {
+        advance(lexer);
+        if (lexer->lookahead == '-') {
+            advance(lexer);
+            lexer->mark_end(lexer);
+            lexer->result_symbol = STATEMENT_TAG_TRIM_OPEN;
+            return true;
+        }
+        if (lexer->lookahead == '+') {
+            advance(lexer);
+            lexer->mark_end(lexer);
+            lexer->result_symbol = STATEMENT_TAG_LSTRIP_OPEN;
+            return true;
+        }
+        lexer->mark_end(lexer);
+        lexer->result_symbol = STATEMENT_TAG_OPEN;
+        return true;
+    }
+
+    /* {{  {{- — expression tag open (emit the precise variant) */
+    if (lexer->lookahead == '{' &&
+        (valid_symbols[EXPRESSION_TAG_OPEN] || valid_symbols[EXPRESSION_TAG_TRIM_OPEN])) {
+        advance(lexer);
+        if (lexer->lookahead == '-') {
+            advance(lexer);
+            lexer->mark_end(lexer);
+            lexer->result_symbol = EXPRESSION_TAG_TRIM_OPEN;
+            return true;
+        }
+        lexer->mark_end(lexer);
+        lexer->result_symbol = EXPRESSION_TAG_OPEN;
+        return true;
+    }
+
+    /* {#  {#- — comment tag; let the internal lexer match the literal '{#'. */
+    if (lexer->lookahead == '#') return false;
+
+    /* '{' followed by anything else: include it in raw text. */
+    return valid_symbols[RAW_TEXT] ? scan_raw_text_from(lexer, true) : false;
+}
+
+
+/*
+ * Scan statement tag close: %}  -%}
+ * Skip leading whitespace — the scanner is responsible for consuming optional
+ * spaces/tabs between the last code token and the close marker.
+ */
+static bool scan_statement_tag_close(TSLexer *lexer) {
+    while (lexer->lookahead == ' ' || lexer->lookahead == '\t' ||
+           lexer->lookahead == '\r' || lexer->lookahead == '\n')
+        skip(lexer);
+
+    if (lexer->lookahead == '-') {
+        advance(lexer);
+        if (lexer->lookahead != '%') return false;
+        advance(lexer);
+        if (lexer->lookahead != '}') return false;
+        advance(lexer);
+        lexer->mark_end(lexer);
+        lexer->result_symbol = STATEMENT_TAG_TRIM_CLOSE;
+        return true;
+    }
+    if (lexer->lookahead == '%') {
+        advance(lexer);
+        if (lexer->lookahead != '}') return false;
+        advance(lexer);
+        lexer->mark_end(lexer);
+        lexer->result_symbol = STATEMENT_TAG_CLOSE;
+        return true;
+    }
+    return false;
+}
+
+/*
+ * Scan expression tag close: }}  -}}
+ * Skip leading whitespace — spaces between the expression and }} are ignored.
+ */
+static bool scan_expression_tag_close(TSLexer *lexer) {
+    while (lexer->lookahead == ' ' || lexer->lookahead == '\t' ||
+           lexer->lookahead == '\r' || lexer->lookahead == '\n')
+        skip(lexer);
+
+    if (lexer->lookahead == '-') {
+        advance(lexer);
+        if (lexer->lookahead != '}') return false;
+        advance(lexer);
+        if (lexer->lookahead != '}') return false;
+        advance(lexer);
+        lexer->mark_end(lexer);
+        lexer->result_symbol = EXPRESSION_TAG_TRIM_CLOSE;
+        return true;
+    }
+    if (lexer->lookahead == '}') {
+        advance(lexer);
+        if (lexer->lookahead != '}') return false;
+        advance(lexer);
+        lexer->mark_end(lexer);
+        lexer->result_symbol = EXPRESSION_TAG_CLOSE;
+        return true;
+    }
+    return false;
+}
+
+/* -------------------------------------------------------------------------
+ * Code-mode tokens (carried over and extended from the original scanner)
+ * ---------------------------------------------------------------------- */
+
+static bool scan_template_chars(TSLexer *lexer) {
+    lexer->result_symbol = TEMPLATE_CHARS;
+    for (bool has_content = false;; has_content = true) {
+        lexer->mark_end(lexer);
+        switch (lexer->lookahead) {
+            case '`': return has_content;
+            case '\0': return false;
+            case '$':
+                advance(lexer);
+                if (lexer->lookahead == '{') return has_content;
+                break;
+            case '\\': return has_content;
+            default: advance(lexer);
+        }
+    }
+}
+
+/*
+ * Return true if the lookahead is the start of %} or -%} (statement tag
+ * close).  Used during ASI scanning to allow a zero-length semicolon to be
+ * inserted immediately before the tag close without consuming any characters.
+ */
+static bool lookahead_is_stmt_close(TSLexer *lexer) {
+    if (lexer->lookahead == '%') {
+        advance(lexer);
+        return lexer->lookahead == '}';
+    }
+    if (lexer->lookahead == '-') {
+        advance(lexer);
+        if (lexer->lookahead == '%') {
+            advance(lexer);
+            return lexer->lookahead == '}';
+        }
+    }
+    return false;
+}
+
+/*
+ * Automatic Semicolon Insertion (ECMA-262 §12.10).
+ *
+ * Extended to allow ASI immediately before %} and -%} so that the last
+ * statement in a statement tag does not need an explicit trailing semicolon:
+ *   {% let x = 1 %}      — works without a semicolon
+ *   {% return val %}     — works without a semicolon
+ *
+ * The tag-close characters are never consumed; mark_end stays at position 0,
+ * so the zero-length semicolon token is emitted and the scanner is called
+ * again immediately at the same position for STATEMENT_TAG_CLOSE.
+ */
+static bool scan_automatic_semicolon(TSLexer *lexer) {
+    lexer->result_symbol = AUTOMATIC_SEMICOLON;
+    lexer->mark_end(lexer);
+
+    /* ECMAScript rule 1: '}' → insert */
+    if (lexer->lookahead == '}') return true;
+    /* ECMAScript rule 3: EOF → insert */
+    if (lexer->lookahead == 0) return true;
+
+    /* Ucode extension: %} or -%} at end of statement tag → insert */
+    if (lexer->lookahead == '%' || lexer->lookahead == '-') {
+        if (lookahead_is_stmt_close(lexer)) return true;
+        /* lookahead_is_stmt_close advanced but mark_end is still at 0,
+           so the peek is harmless — return false to suppress ASI for
+           regular '-' or '%' continuations. */
+        return false;
+    }
+
+    /*
+     * ECMAScript rule 2: scan for a line terminator before the next token.
+     * Skip inline whitespace and comments; bail on anything else on the
+     * same line.
+     */
+    for (;;) {
+        if (lexer->lookahead == 0) return true;
+        if (lexer->lookahead == '}') return true;
+
+        if (lexer->lookahead == '\r' || lexer->lookahead == '\n' ||
+            lexer->lookahead == 0x2028 || lexer->lookahead == 0x2029) {
+            skip(lexer);
+            break; /* found line terminator */
+        }
+
+        if (iswspace(lexer->lookahead)) { skip(lexer); continue; }
+
+        /* Line comment — skip to end of line */
+        if (lexer->lookahead == '/') {
+            skip(lexer);
+            if (lexer->lookahead == '/') {
+                skip(lexer);
+                while (lexer->lookahead != 0 &&
+                       lexer->lookahead != '\r' && lexer->lookahead != '\n' &&
+                       lexer->lookahead != 0x2028 && lexer->lookahead != 0x2029)
+                    skip(lexer);
+                continue;
+            }
+            /* Block comment — check for embedded newline */
+            if (lexer->lookahead == '*') {
+                skip(lexer);
+                bool has_newline = false;
+                while (lexer->lookahead != 0) {
+                    if (lexer->lookahead == '\r' || lexer->lookahead == '\n' ||
+                        lexer->lookahead == 0x2028 || lexer->lookahead == 0x2029)
+                        has_newline = true;
+                    if (lexer->lookahead == '*') {
+                        skip(lexer);
+                        if (lexer->lookahead == '/') { skip(lexer); break; }
+                    } else {
+                        skip(lexer);
+                    }
+                }
+                if (has_newline) break;
+                continue;
+            }
+            /* Division slash — not a comment, no ASI */
+            return false;
+        }
+
+        /* %} / -%} on the same line as the expression: still allow ASI */
+        if (lexer->lookahead == '%' || lexer->lookahead == '-') {
+            if (lookahead_is_stmt_close(lexer)) return true;
+            return false;
+        }
+
+        /* Any other non-whitespace on the same line → no ASI */
+        return false;
+    }
+
+    /*
+     * Found a line terminator.  Skip trailing whitespace/comments after it,
+     * then check whether the next real token would suppress ASI.
+     */
+    for (;;) {
+        if (lexer->lookahead == 0) return true;
+
+        if (iswspace(lexer->lookahead)) { skip(lexer); continue; }
+
+        if (lexer->lookahead == '/') {
+            skip(lexer);
+            if (lexer->lookahead == '/') {
+                skip(lexer);
+                while (lexer->lookahead != 0 &&
+                       lexer->lookahead != '\r' && lexer->lookahead != '\n' &&
+                       lexer->lookahead != 0x2028 && lexer->lookahead != 0x2029)
+                    skip(lexer);
+                continue;
+            }
+            if (lexer->lookahead == '*') {
+                skip(lexer);
+                while (lexer->lookahead != 0) {
+                    if (lexer->lookahead == '*') {
+                        skip(lexer);
+                        if (lexer->lookahead == '/') { skip(lexer); break; }
+                    } else {
+                        skip(lexer);
+                    }
+                }
+                continue;
+            }
+            return false; /* division slash after newline → no ASI */
+        }
+        break;
+    }
+
+    /*
+     * Tokens that can continue the prior expression suppress ASI.
+     * %} and -%} are tag closers and always allow ASI even though they
+     * start with '%' or '-'.
+     */
+    switch (lexer->lookahead) {
+        case '(': case '[': case '`':
+        case '.': case ',': case ';':
+        case '+': case '*':
+        case '=': case '<': case '>': case '!': case '~':
+        case '&': case '|': case '^': case '?':
+            return false;
+        case '-':
+        case '%':
+            if (lookahead_is_stmt_close(lexer)) return true;
+            return false;
+        default:
+            return true;
+    }
+}
+
+static bool scan_ternary_qmark(TSLexer *lexer) {
+    while (lexer->lookahead != '\r' && lexer->lookahead != '\n' &&
+           lexer->lookahead != 0x2028 && lexer->lookahead != 0x2029 &&
+           iswspace(lexer->lookahead))
+        skip(lexer);
+
+    if (lexer->lookahead != '?') return false;
+    advance(lexer);
+
+    if (lexer->lookahead == '?') return false; /* nullish coalescing */
+
+    lexer->mark_end(lexer);
+    lexer->result_symbol = TERNARY_QMARK;
+
+    if (lexer->lookahead == '.') {
+        advance(lexer);
+        return iswdigit(lexer->lookahead); /* ?. followed by digit is ternary */
+    }
+
+    return true;
+}
+
+/* -------------------------------------------------------------------------
+ * Main dispatch
+ * ---------------------------------------------------------------------- */
+
+static bool ucode_scanner_scan(
+    void *payload, TSLexer *lexer, const bool *valid_symbols
+) {
+    (void)payload;
+
+    /*
+     * Error-recovery guard.
+     *
+     * During error recovery tree-sitter sets every external token valid at
+     * once.  AUTOMATIC_SEMICOLON (code context) and RAW_TEXT (markup context)
+     * are never simultaneously valid in a normal parse, so their co-presence
+     * signals error recovery.  Return false so the parser uses its own grammar
+     * tokens for recovery instead of the scanner consuming raw_text.
+     */
+    if (valid_symbols[AUTOMATIC_SEMICOLON] && valid_symbols[RAW_TEXT])
+        return false;
+
+    /*
+     * Template chars: only when we are unambiguously inside a template
+     * literal body (not competing with ASI).
+     */
+    if (valid_symbols[TEMPLATE_CHARS] && !valid_symbols[AUTOMATIC_SEMICOLON])
+        return scan_template_chars(lexer);
+
+    /*
+     * Markup-mode tokens.
+     *
+     * All three markup openers are dispatched through scan_markup(), which
+     * handles the '{' character atomically — advancing past it once and then
+     * inspecting the second character — to avoid the position-skew bug that
+     * arises when sequential sub-scanners each try to advance past '{'.
+     */
+    if (valid_symbols[RAW_TEXT] ||
+        valid_symbols[STATEMENT_TAG_OPEN] ||
+        valid_symbols[STATEMENT_TAG_TRIM_OPEN] ||
+        valid_symbols[STATEMENT_TAG_LSTRIP_OPEN] ||
+        valid_symbols[EXPRESSION_TAG_OPEN] ||
+        valid_symbols[EXPRESSION_TAG_TRIM_OPEN]) {
+        if (scan_markup(lexer, valid_symbols)) return true;
+    }
+
+    /*
+     * Tag close tokens.  Checked before ASI so that %} / -%} / }} / -}}
+     * are preferred over a zero-length semicolon when both are valid.
+     * When neither matches, fall through to ASI.
+     */
+    if (valid_symbols[STATEMENT_TAG_CLOSE] || valid_symbols[STATEMENT_TAG_TRIM_CLOSE]) {
+        if (scan_statement_tag_close(lexer)) return true;
+    }
+    if (valid_symbols[EXPRESSION_TAG_CLOSE] || valid_symbols[EXPRESSION_TAG_TRIM_CLOSE]) {
+        if (scan_expression_tag_close(lexer)) return true;
+    }
+
+    /* ASI and ternary */
+    if (valid_symbols[AUTOMATIC_SEMICOLON]) {
+        if (scan_automatic_semicolon(lexer)) return true;
+        if (valid_symbols[TERNARY_QMARK]) return scan_ternary_qmark(lexer);
+        return false;
+    }
+
+    if (valid_symbols[TERNARY_QMARK])
+        return scan_ternary_qmark(lexer);
+
+    return false;
+}
+
+#endif /* UCODE_SCANNER_IMPL_H_ */

package/tree-sitter.json

@@ -1,48 +1,59 @@
 {
   "grammars": [
     {
-      "name": "ucode_tmpl",
-      "camelcase": "UcodeTmpl",
-      "scope": "source.uc.tmpl",
-      "path": "./tmpl",
+      "name": "ucode",
+      "camelcase": "Ucode",
+      "scope": "source.uc",
+      "path": ".",
       "file-types": [
-        "uc",
-        "utpl"
+        "ucode", "uc", "ut"
       ],
-      "content-regex": "(?m)^\\s*\\{[%{#]",
       "highlights": [
-        "tmpl/queries/highlights.scm"
+        "queries/highlights.scm"
       ],
       "locals": [
-        "tmpl/queries/locals.scm"
+        "queries/locals.scm"
       ],
-      "injections": [
-        "tmpl/queries/injections.scm"
+      "tags": [
+        "queries/tags.scm"
       ],
-      "injection-regex": "^ucode_tmpl$"
+      "injection-regex": "^ucode$"
     },
     {
-      "name": "ucode",
-      "camelcase": "Ucode",
-      "scope": "source.uc",
-      "path": ".",
+      "name": "ucode_markup",
+      "camelcase": "UcodeMarkup",
+      "scope": "source.ucode.markup",
+      "path": "./markup",
       "file-types": [
-        "uc"
+        "ucode", "uc", "ut"
       ],
+      "content-regex": "(?m)^\\s*\\{[%{#]",
       "highlights": [
-        "queries/highlights.scm"
+        "markup/queries/highlights.scm"
       ],
       "locals": [
-        "queries/locals.scm"
+        "markup/queries/locals.scm"
+      ],
+      "injections": [
+        "markup/queries/injections.scm"
       ],
       "tags": [
-        "queries/tags.scm"
+        "markup/queries/tags.scm"
       ],
-      "injection-regex": "^ucode$"
+      "folds": [
+        "markup/queries/folds.scm"
+      ],
+      "indents": [
+        "markup/queries/indents.scm"
+      ],
+      "textobjects": [
+        "markup/queries/textobjects.scm"
+      ],
+      "injection-regex": "^ucode_markup$"
     }
   ],
   "metadata": {
-    "version": "0.3.0",
+    "version": "0.4.0",
     "license": "MIT",
     "description": "Ucode grammar for tree-sitter",
     "links": {

package/tmpl/grammar.js

@@ -1,68 +0,0 @@
-/**
- * @file Ucode template grammar for tree-sitter
- * @license MIT
- *
- * Handles .uc.tmpl / .utpl files: raw text interspersed with ucode code
- * blocks ({%...%}), expression blocks ({{...}}), and comments ({#...#}).
- *
- * The grammar captures raw text verbatim and the inner content of code /
- * expression blocks as opaque `code` nodes.  Editors use language injection
- * (see tmpl/queries/injections.scm) to parse those nodes as ucode.
- *
- * Whitespace-stripping markers are supported on both openers and closers:
- *
- *   Opener variants   Closer variants
- *   ─────────────     ──────────────
- *   {%   {%-  {%+     %}   -%}       (statement)
- *   {{   {{-           }}   -}}       (expression)
- *   {#   {#-           #}   -#}       (comment)
- *
- * {%-  strips trailing whitespace from the preceding raw-text block.
- * -%}  strips leading whitespace from the following raw-text block.
- * {%+  suppresses stripping even when lstrip_blocks is configured.
- */
-
-/// <reference types="tree-sitter-cli/dsl" />
-// @ts-check
-
-module.exports = grammar({
-  name: 'ucode_tmpl',
-
-  externals: $ => [
-    $._raw_text,     // literal text outside any tag
-    $._stmt_code,    // content between {% ... %} (before the closer)
-    $._expr_code,    // content between {{ ... }} (before the closer)
-    $._comment_body, // content between {# ... #} (before the closer)
-    $.eof_close,     // emitted at EOF when inside a statement tag (implicit close)
-  ],
-
-  // The template scanner handles all whitespace explicitly; no implicit extras.
-  extras: _ => [],
-
-  rules: {
-    document: $ => repeat(choice(
-      alias($._raw_text, $.raw_text),
-      $.statement_tag,
-      $.expression_tag,
-      $.comment_tag,
-    )),
-
-    statement_tag: $ => seq(
-      field('open',  choice('{%-', '{%+', '{%')),
-      field('code',  optional(alias($._stmt_code, $.code))),
-      field('close', choice('-%}', '%}', $.eof_close)),
-    ),
-
-    expression_tag: $ => seq(
-      field('open',  choice('{{-', '{{')),
-      field('code',  optional(alias($._expr_code, $.code))),
-      field('close', choice('-}}', '}}')),
-    ),
-
-    comment_tag: $ => seq(
-      field('open',    choice('{#-', '{#')),
-      field('content', optional(alias($._comment_body, $.comment_content))),
-      field('close',   choice('-#}', '#}')),
-    ),
-  },
-});

package/tmpl/queries/folds.scm

@@ -1,4 +0,0 @@
-; Fold queries for ucode_tmpl.
-; Folds are not meaningful at the template document level since each tag is
-; typically one or a few lines.  Folding inside code blocks is handled by the
-; injected ucode grammar.

package/tmpl/queries/highlights.scm

@@ -1,23 +0,0 @@
-; Highlight queries for ucode_tmpl.
-; Template structure is styled here; ucode code inside tags is highlighted
-; via language injection (see injections.scm).
-
-; -------------------------------------------------------------------------
-; Tag delimiters
-; -------------------------------------------------------------------------
-
-[
-  "{%"  "%}"
-  "{%-" "-%}"
-  "{%+"
-  "{{"  "}}"
-  "{{-" "-}}"
-  "{#"  "#}"
-  "{#-" "-#}"
-] @keyword
-
-; -------------------------------------------------------------------------
-; Template comments
-; -------------------------------------------------------------------------
-
-(comment_tag) @comment @spell

package/tmpl/queries/indents.scm

@@ -1,5 +0,0 @@
-; Indentation queries for ucode_tmpl.
-; Raw text between tags is not indented by the template engine, so there are
-; no template-level indent rules.  Code inside statement_tag and expression_tag
-; is parsed via language injection (see injections.scm) and indented according
-; to the injected ucode grammar's indents.scm.

package/tmpl/queries/injections.scm

@@ -1,8 +0,0 @@
-; Injection queries for ucode_tmpl.
-; Instructs editors to parse code/expression block content as ucode.
-
-((statement_tag (code) @injection.content)
- (#set! injection.language "ucode"))
-
-((expression_tag (code) @injection.content)
- (#set! injection.language "ucode"))