tree-sitter-ucode 0.2.0 → 0.3.0

package/README.md

@@ -7,7 +7,12 @@ Two grammars are provided:
 | Grammar | Scope | File types |
 |---------|-------|------------|
 | `ucode` | `source.uc` | `.uc` |
-| `ucode_tmpl` | `source.uc.tmpl` | `.uc.tmpl`, `.utpl` |
+| `ucode_tmpl` | `source.uc.tmpl` | `.uc` (template files — detected by content) |
+
+Both grammars use the `.uc` extension. Template files are distinguished from plain
+code files by content: any `.uc` file whose first tag opener (`{%`, `{{`, or `{#`)
+appears at the start of a line is automatically parsed by `ucode_tmpl`. Plain code
+files fall back to `ucode`. See [File-type detection](#file-type-detection) below.
 
 ## Ucode vs JavaScript
 
@@ -55,10 +60,18 @@ npm test             # runs tree-sitter test for ucode and ucode_tmpl
 To filter by corpus file name:
 
 ```sh
-npx tree-sitter test --file-name control_flow
+npx tree-sitter test --lib-path ucode.so --lang-name ucode --file-name control_flow
 npx tree-sitter test -p tmpl --file-name template
 ```
 
+## File-type detection
+
+Both grammars claim the `.uc` extension. Tools that respect `content-regex` in
+`tree-sitter.json` (including the tree-sitter CLI ≥ 0.24) automatically route
+template files to `ucode_tmpl` when a tag opener appears at the start of a line.
+Editors that manage their own filetype dispatch (Neovim, Helix) need an explicit
+rule — see the editor sections below.
+
 ## Use in Neovim (nvim-treesitter)
 
 Add to your nvim-treesitter config (e.g. `~/.config/nvim/lua/plugins/treesitter.lua`):
@@ -85,15 +98,26 @@ parser_config.ucode_tmpl = {
 }
 ```
 
-Associate `.uc` and `.uc.tmpl` files with the right filetypes:
+Associate `.uc` files with the right filetype. Since nvim-treesitter does not
+use `content-regex`, the mapping must be done with a `BufRead` autocmd or a
+filetype function that inspects the file content:
 
 ```lua
 vim.filetype.add({
   extension = {
-    uc   = "ucode",
-    utpl = "ucode_tmpl",
+    uc = function(path)
+      -- Files whose first tag opener is at the start of a line are templates
+      local f = io.open(path, "r")
+      if f then
+        local content = f:read("*a")
+        f:close()
+        if content:find("^%s*{[%%{#]", 1, false) or content:find("\n%s*{[%%{#]") then
+          return "ucode_tmpl"
+        end
+      end
+      return "ucode"
+    end,
   },
-  pattern = { [".*%.uc%.tmpl"] = "ucode_tmpl" },
 })
 ```
 
@@ -103,32 +127,38 @@ Add to `~/.config/helix/languages.toml`:
 
 ```toml
 [[language]]
-name        = "ucode"
-scope       = "source.uc"
-file-types  = ["uc"]
+name          = "ucode"
+scope         = "source.uc"
+file-types    = [{ glob = "*.uc" }]
 comment-token = "//"
-indent      = { tab-width = 2, unit = "  " }
-grammar     = "ucode"
+indent        = { tab-width = 2, unit = "  " }
+grammar       = "ucode"
 
 [[language]]
-name        = "ucode-tmpl"
-scope       = "source.uc.tmpl"
-file-types  = ["uc.tmpl", "utpl"]
-grammar     = "ucode_tmpl"
+name          = "ucode-tmpl"
+scope         = "source.uc.tmpl"
+comment-token = "{#"
+indent        = { tab-width = 2, unit = "  " }
+grammar       = "ucode_tmpl"
 
 [[grammar]]
 name   = "ucode"
-source = { git = "https://github.com/m00qek/tree-sitter-ucode", rev = "main" }
+source = { git = "https://github.com/m00qek/tree-sitter-ucode", rev = "v0.3.0" }
 
 [[grammar]]
 name   = "ucode_tmpl"
-source = { git = "https://github.com/m00qek/tree-sitter-ucode", rev = "main", subpath = "tmpl" }
+source = { git = "https://github.com/m00qek/tree-sitter-ucode", rev = "v0.3.0", subpath = "tmpl" }
 ```
 
-## Template files (.uc.tmpl / .utpl)
+Helix does not support content-based filetype detection. To open a `.uc`
+template file as `ucode-tmpl`, use `:set-language ucode-tmpl` in command mode,
+or configure a file-specific override via a `.helix/languages.toml` in your
+project.
+
+## Template files
 
-Template files mix raw text with code tags. The `ucode_tmpl` grammar produces
-a document tree; editors use language injection to apply ucode highlighting
+Template files mix raw text with code tags. The `ucode_tmpl` grammar produces a
+`document` tree; editors use language injection to apply ucode highlighting
 inside the code and expression tags.
 
 | Tag | Purpose |
@@ -141,7 +171,17 @@ inside the code and expression tags.
 | `{%+ ... %}` | Statement block — suppress `lstrip_blocks` stripping |
 | `{#- ... -#}` | Comment — strip whitespace on both sides |
 
-Opener and closer markers are independent: any opener variant may be combined with any closer variant. `{%-` / `{{-` / `{#-` strip the preceding raw text; `-%}` / `-}}` / `-#}` strip the following raw text. `{%+` suppresses `lstrip_blocks` stripping and may be combined with `-%}` (e.g. `{%+ ... -%}`).
+Opener and closer markers are independent: any opener variant may be combined
+with any closer variant. `{%-` / `{{-` / `{#-` strip the preceding raw text;
+`-%}` / `-}}` / `-#}` strip the following raw text. `{%+` suppresses
+`lstrip_blocks` stripping and may be combined with `-%}`.
+
+**EOF-implicit close**: a `{%` statement tag that reaches end-of-file without
+an explicit `%}` is treated as implicitly closed. This supports the common
+OpenWrt pattern of a file that opens one `{%` block at the top and contains
+only ucode code, with no closing `%}`. The parse tree shows an `(eof_close)`
+node in the `close` field. Expression (`{{`) and comment (`{#`) tags still
+require explicit closers.
 
 Example:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tree-sitter-ucode",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Ucode grammar for tree-sitter",
   "repository": {
     "type": "git",
@@ -35,7 +35,7 @@
   },
   "devDependencies": {
     "prebuildify": "^6.0.1",
-    "tree-sitter-cli": "^0.26.0"
+    "tree-sitter-cli": "0.26.9"
   },
   "peerDependencies": {
     "tree-sitter": "^0.22.0"
@@ -48,7 +48,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",
-    "test": "tree-sitter test && tree-sitter test -p tmpl",
+    "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/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/src/parser.c

@@ -32491,7 +32491,7 @@ TS_PUBLIC const TSLanguage *tree_sitter_ucode(void) {
     .max_reserved_word_set_size = 28,
     .metadata = {
       .major_version = 0,
-      .minor_version = 2,
+      .minor_version = 3,
       .patch_version = 0,
     },
   };

package/tmpl/grammar.js

@@ -33,6 +33,7 @@ module.exports = grammar({
     $._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.
@@ -49,7 +50,7 @@ module.exports = grammar({
     statement_tag: $ => seq(
       field('open',  choice('{%-', '{%+', '{%')),
       field('code',  optional(alias($._stmt_code, $.code))),
-      field('close', choice('-%}', '%}')),
+      field('close', choice('-%}', '%}', $.eof_close)),
     ),
 
     expression_tag: $ => seq(

package/tmpl/queries/folds.scm

@@ -0,0 +1,4 @@
+; 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/indents.scm

@@ -0,0 +1,5 @@
+; 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/src/grammar.json

@@ -89,6 +89,10 @@
               {
                 "type": "STRING",
                 "value": "%}"
+              },
+              {
+                "type": "SYMBOL",
+                "name": "eof_close"
               }
             ]
           }
@@ -235,6 +239,10 @@
     {
       "type": "SYMBOL",
       "name": "_comment_body"
+    },
+    {
+      "type": "SYMBOL",
+      "name": "eof_close"
     }
   ],
   "inline": [],

package/tmpl/src/node-types.json

@@ -130,6 +130,10 @@
           {
             "type": "-%}",
             "named": false
+          },
+          {
+            "type": "eof_close",
+            "named": true
           }
         ]
       },
@@ -191,6 +195,10 @@
     "type": "comment_content",
     "named": true
   },
+  {
+    "type": "eof_close",
+    "named": true
+  },
   {
     "type": "raw_text",
     "named": true

package/tmpl/src/parser.c

@@ -9,10 +9,10 @@
 #define LANGUAGE_VERSION 15
 #define STATE_COUNT 17
 #define LARGE_STATE_COUNT 4
-#define SYMBOL_COUNT 23
+#define SYMBOL_COUNT 24
 #define ALIAS_COUNT 0
-#define TOKEN_COUNT 18
-#define EXTERNAL_TOKEN_COUNT 4
+#define TOKEN_COUNT 19
+#define EXTERNAL_TOKEN_COUNT 5
 #define FIELD_COUNT 4
 #define MAX_ALIAS_SEQUENCE_LENGTH 3
 #define MAX_RESERVED_WORD_SET_SIZE 0
@@ -37,11 +37,12 @@ enum ts_symbol_identifiers {
   sym__stmt_code = 15,
   sym__expr_code = 16,
   sym__comment_body = 17,
-  sym_document = 18,
-  sym_statement_tag = 19,
-  sym_expression_tag = 20,
-  sym_comment_tag = 21,
-  aux_sym_document_repeat1 = 22,
+  sym_eof_close = 18,
+  sym_document = 19,
+  sym_statement_tag = 20,
+  sym_expression_tag = 21,
+  sym_comment_tag = 22,
+  aux_sym_document_repeat1 = 23,
 };
 
 static const char * const ts_symbol_names[] = {
@@ -63,6 +64,7 @@ static const char * const ts_symbol_names[] = {
   [sym__stmt_code] = "code",
   [sym__expr_code] = "code",
   [sym__comment_body] = "comment_content",
+  [sym_eof_close] = "eof_close",
   [sym_document] = "document",
   [sym_statement_tag] = "statement_tag",
   [sym_expression_tag] = "expression_tag",
@@ -89,6 +91,7 @@ static const TSSymbol ts_symbol_map[] = {
   [sym__stmt_code] = sym__stmt_code,
   [sym__expr_code] = sym__stmt_code,
   [sym__comment_body] = sym__comment_body,
+  [sym_eof_close] = sym_eof_close,
   [sym_document] = sym_document,
   [sym_statement_tag] = sym_statement_tag,
   [sym_expression_tag] = sym_expression_tag,
@@ -169,6 +172,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = {
     .visible = true,
     .named = true,
   },
+  [sym_eof_close] = {
+    .visible = true,
+    .named = true,
+  },
   [sym_document] = {
     .visible = true,
     .named = true,
@@ -359,7 +366,7 @@ static const TSLexerMode ts_lex_modes[STATE_COUNT] = {
   [10] = {.lex_state = 0, .external_lex_state = 3},
   [11] = {.lex_state = 0, .external_lex_state = 4},
   [12] = {.lex_state = 0, .external_lex_state = 5},
-  [13] = {.lex_state = 0},
+  [13] = {.lex_state = 0, .external_lex_state = 6},
   [14] = {.lex_state = 0},
   [15] = {.lex_state = 0},
   [16] = {.lex_state = 0},
@@ -385,6 +392,7 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [sym__stmt_code] = ACTIONS(1),
     [sym__expr_code] = ACTIONS(1),
     [sym__comment_body] = ACTIONS(1),
+    [sym_eof_close] = ACTIONS(1),
   },
   [STATE(1)] = {
     [sym_document] = STATE(16),
@@ -510,34 +518,36 @@ static const uint16_t ts_small_parse_table[] = {
   [84] = 2,
     ACTIONS(72), 1,
       sym__stmt_code,
-    ACTIONS(70), 2,
+    ACTIONS(70), 3,
+      sym_eof_close,
       anon_sym_DASH_PERCENT_RBRACE,
       anon_sym_PERCENT_RBRACE,
-  [92] = 2,
+  [93] = 2,
     ACTIONS(76), 1,
       sym__expr_code,
     ACTIONS(74), 2,
       anon_sym_DASH_RBRACE_RBRACE,
       anon_sym_RBRACE_RBRACE,
-  [100] = 2,
+  [101] = 2,
     ACTIONS(80), 1,
       sym__comment_body,
     ACTIONS(78), 2,
       anon_sym_DASH_POUND_RBRACE,
       anon_sym_POUND_RBRACE,
-  [108] = 1,
-    ACTIONS(82), 2,
+  [109] = 1,
+    ACTIONS(82), 3,
+      sym_eof_close,
       anon_sym_DASH_PERCENT_RBRACE,
       anon_sym_PERCENT_RBRACE,
-  [113] = 1,
+  [115] = 1,
     ACTIONS(84), 2,
       anon_sym_DASH_RBRACE_RBRACE,
       anon_sym_RBRACE_RBRACE,
-  [118] = 1,
+  [120] = 1,
     ACTIONS(86), 2,
       anon_sym_DASH_POUND_RBRACE,
       anon_sym_POUND_RBRACE,
-  [123] = 1,
+  [125] = 1,
     ACTIONS(88), 1,
       ts_builtin_sym_end,
 };
@@ -550,12 +560,12 @@ static const uint32_t ts_small_parse_table_map[] = {
   [SMALL_STATE(8)] = 56,
   [SMALL_STATE(9)] = 70,
   [SMALL_STATE(10)] = 84,
-  [SMALL_STATE(11)] = 92,
-  [SMALL_STATE(12)] = 100,
-  [SMALL_STATE(13)] = 108,
-  [SMALL_STATE(14)] = 113,
-  [SMALL_STATE(15)] = 118,
-  [SMALL_STATE(16)] = 123,
+  [SMALL_STATE(11)] = 93,
+  [SMALL_STATE(12)] = 101,
+  [SMALL_STATE(13)] = 109,
+  [SMALL_STATE(14)] = 115,
+  [SMALL_STATE(15)] = 120,
+  [SMALL_STATE(16)] = 125,
 };
 
 static const TSParseActionEntry ts_parse_actions[] = {
@@ -608,6 +618,7 @@ enum ts_external_scanner_symbol_identifiers {
   ts_external_token__stmt_code = 1,
   ts_external_token__expr_code = 2,
   ts_external_token__comment_body = 3,
+  ts_external_token_eof_close = 4,
 };
 
 static const TSSymbol ts_external_scanner_symbol_map[EXTERNAL_TOKEN_COUNT] = {
@@ -615,20 +626,23 @@ static const TSSymbol ts_external_scanner_symbol_map[EXTERNAL_TOKEN_COUNT] = {
   [ts_external_token__stmt_code] = sym__stmt_code,
   [ts_external_token__expr_code] = sym__expr_code,
   [ts_external_token__comment_body] = sym__comment_body,
+  [ts_external_token_eof_close] = sym_eof_close,
 };
 
-static const bool ts_external_scanner_states[6][EXTERNAL_TOKEN_COUNT] = {
+static const bool ts_external_scanner_states[7][EXTERNAL_TOKEN_COUNT] = {
   [1] = {
     [ts_external_token__raw_text] = true,
     [ts_external_token__stmt_code] = true,
     [ts_external_token__expr_code] = true,
     [ts_external_token__comment_body] = true,
+    [ts_external_token_eof_close] = true,
   },
   [2] = {
     [ts_external_token__raw_text] = true,
   },
   [3] = {
     [ts_external_token__stmt_code] = true,
+    [ts_external_token_eof_close] = true,
   },
   [4] = {
     [ts_external_token__expr_code] = true,
@@ -636,6 +650,9 @@ static const bool ts_external_scanner_states[6][EXTERNAL_TOKEN_COUNT] = {
   [5] = {
     [ts_external_token__comment_body] = true,
   },
+  [6] = {
+    [ts_external_token_eof_close] = true,
+  },
 };
 
 #ifdef __cplusplus
@@ -696,7 +713,7 @@ TS_PUBLIC const TSLanguage *tree_sitter_ucode_tmpl(void) {
     .max_reserved_word_set_size = 0,
     .metadata = {
       .major_version = 0,
-      .minor_version = 2,
+      .minor_version = 3,
       .patch_version = 0,
     },
   };

package/tmpl/src/scanner.c

@@ -6,6 +6,7 @@ enum TokenType {
     STMT_CODE,
     EXPR_CODE,
     COMMENT_BODY,
+    EOF_CLOSE,
 };
 
 void *tree_sitter_ucode_tmpl_external_scanner_create(void)  { return NULL; }
@@ -160,6 +161,10 @@ bool tree_sitter_ucode_tmpl_external_scanner_scan(
 ) {
     (void)payload;
 
+    if (valid_symbols[EOF_CLOSE] && lexer->lookahead == '\0') {
+        lexer->result_symbol = EOF_CLOSE;
+        return true;
+    }
     if (valid_symbols[RAW_TEXT])     return scan_raw_text(lexer);
     if (valid_symbols[STMT_CODE])    return scan_stmt_code(lexer);
     if (valid_symbols[EXPR_CODE])    return scan_expr_code(lexer);

package/tree-sitter.json

@@ -1,33 +1,15 @@
 {
   "grammars": [
-    {
-      "name": "ucode",
-      "camelcase": "Ucode",
-      "scope": "source.uc",
-      "path": ".",
-      "file-types": [
-        "uc"
-      ],
-      "highlights": [
-        "queries/highlights.scm"
-      ],
-      "locals": [
-        "queries/locals.scm"
-      ],
-      "tags": [
-        "queries/tags.scm"
-      ],
-      "injection-regex": "^ucode$"
-    },
     {
       "name": "ucode_tmpl",
       "camelcase": "UcodeTmpl",
       "scope": "source.uc.tmpl",
       "path": "./tmpl",
       "file-types": [
-        "uc.tmpl",
+        "uc",
         "utpl"
       ],
+      "content-regex": "(?m)^\\s*\\{[%{#]",
       "highlights": [
         "tmpl/queries/highlights.scm"
       ],
@@ -38,10 +20,29 @@
         "tmpl/queries/injections.scm"
       ],
       "injection-regex": "^ucode_tmpl$"
+    },
+    {
+      "name": "ucode",
+      "camelcase": "Ucode",
+      "scope": "source.uc",
+      "path": ".",
+      "file-types": [
+        "uc"
+      ],
+      "highlights": [
+        "queries/highlights.scm"
+      ],
+      "locals": [
+        "queries/locals.scm"
+      ],
+      "tags": [
+        "queries/tags.scm"
+      ],
+      "injection-regex": "^ucode$"
     }
   ],
   "metadata": {
-    "version": "0.2.0",
+    "version": "0.3.0",
     "license": "MIT",
     "description": "Ucode grammar for tree-sitter",
     "links": {