tree-sitter-ucode 0.3.0 → 0.4.0

package/markup/queries/folds.scm

@@ -0,0 +1,20 @@
+; Fold queries for ucode_markup.
+
+; Code-level folds — same structures appear as real AST nodes inside tags
+[
+  (statement_block)
+  (switch_body)
+  (object)
+  (array)
+] @fold
+
+; Alt-syntax template blocks — fold the entire construct
+[
+  (if_alt_statement)
+  (for_alt_statement)
+  (for_in_alt_statement)
+  (while_alt_statement)
+] @fold
+
+; Colon-body function declarations inside statement tags
+(function_declaration "endfunction") @fold

package/markup/queries/highlights.scm

@@ -0,0 +1,38 @@
+; Markup-mode highlights for ucode_markup grammar
+; (.uc.tmpl files)
+
+; ── Tag delimiters ────────────────────────────────────────────────────────────
+
+(statement_tag_open)        @punctuation.special
+(statement_tag_trim_open)   @punctuation.special
+(statement_tag_lstrip_open) @punctuation.special
+(statement_tag_close)       @punctuation.special
+(statement_tag_trim_close)  @punctuation.special
+(expression_tag_open)       @punctuation.special
+(expression_tag_trim_open)  @punctuation.special
+(expression_tag_close)      @punctuation.special
+(expression_tag_trim_close) @punctuation.special
+
+; ── Comment tags ─────────────────────────────────────────────────────────────
+
+(comment_tag) @comment
+
+; ── Alt-syntax structural keywords ────────────────────────────────────────────
+;
+; These tokens appear between the tag-open external token and the close of the
+; alt header (before the : that ends the condition/header).  They are not
+; injected — they are literal tokens visible in the ucode_markup parse tree.
+
+["if" "elif" "else" "endif"]        @keyword.conditional
+["for" "endfor" "while" "endwhile"] @keyword.repeat
+"in"                                @keyword.operator
+
+(if_alt_statement     ":" @punctuation.delimiter)
+(elif_clause_tag      ":" @punctuation.delimiter)
+(for_alt_statement    ":" @punctuation.delimiter)
+(for_in_alt_statement ":" @punctuation.delimiter)
+(while_alt_statement  ":" @punctuation.delimiter)
+(function_declaration ":" @punctuation.delimiter)
+
+; ── Code tokens inside statement/expression tags are highlighted via injection ─
+; (see markup/queries/injections.scm)

package/markup/queries/indents.scm

@@ -0,0 +1,51 @@
+; Indentation queries for ucode_markup.
+
+; ── Brace-delimited constructs inside statement tags ──────────────────────────
+
+[
+  (statement_block)
+  (switch_body)
+  (object)
+  (array)
+  (arguments)
+  (formal_parameters)
+] @indent.begin
+
+[
+  "}"
+  "]"
+  ")"
+] @indent.end
+
+; ── Alt-syntax template blocks ────────────────────────────────────────────────
+
+(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)
+
+[
+  "endif"
+  "endfor"
+  "endwhile"
+  "endfunction"
+] @indent.end
+
+(else_clause        "else") @indent.branch
+(else_alt_clause    "else") @indent.branch
+(else_alt_clause_tag "else") @indent.branch
+(elif_clause        "elif") @indent.branch
+(elif_clause_tag    "elif") @indent.branch
+
+; else variants have no ':' so @indent.branch alone doesn't open a body scope
+(else_alt_clause)     @indent.begin
+(else_alt_clause_tag) @indent.begin
+
+(elif_clause_tag ":" @indent.begin)
+
+; ── Switch ────────────────────────────────────────────────────────────────────
+
+(switch_case    "case")    @indent.branch
+(switch_default "default") @indent.branch

package/markup/queries/injections.scm

@@ -0,0 +1,40 @@
+; Inject the ucode grammar into statement and expression tag bodies.
+;
+; The entire statement_tag (excluding open/close markers) and the expression
+; inside an expression_tag are highlighted as ucode code.
+
+(statement_tag
+  ((_) @injection.content
+    (#not-type? @injection.content
+      statement_tag_open statement_tag_trim_open statement_tag_lstrip_open
+      statement_tag_close statement_tag_trim_close))
+  (#set! injection.language "ucode"))
+
+(expression_tag
+  ((_) @injection.content
+    (#not-type? @injection.content
+      expression_tag_open expression_tag_trim_open
+      expression_tag_close expression_tag_trim_close))
+  (#set! injection.language "ucode"))
+
+; Alt-syntax header expressions.
+;
+; Conditions and loop headers live directly on the alt-syntax node, not
+; inside a statement_tag, so the captures above do not reach them.  The
+; `open: (_)` guard selects the markup form of each rule (the one with tag
+; delimiters) and excludes the code form that appears inside statement_tag
+; bodies (which are already covered by the statement_tag capture above).
+
+(if_alt_statement    open: (_) condition: (_) @injection.content (#set! injection.language "ucode"))
+(elif_clause_tag                condition: (_) @injection.content (#set! injection.language "ucode"))
+(while_alt_statement open: (_) condition: (_) @injection.content (#set! injection.language "ucode"))
+
+(for_alt_statement open: (_) initializer: (_) @injection.content
+  (#not-type? @injection.content empty_statement)
+  (#set! injection.language "ucode"))
+(for_alt_statement open: (_) condition: (_) @injection.content
+  (#not-type? @injection.content empty_statement)
+  (#set! injection.language "ucode"))
+(for_alt_statement open: (_) increment: (_) @injection.content (#set! injection.language "ucode"))
+
+(for_in_alt_statement open: (_) right: (_) @injection.content (#set! injection.language "ucode"))

package/markup/queries/locals.scm

@@ -0,0 +1,107 @@
+; Locals for ucode_markup.
+; The markup parser produces a single unified tree — code inside {% %} and
+; {{ }} tags is parsed as real AST nodes, not opaque code blobs.  Variable
+; bindings declared in one tag are therefore visible in subsequent sibling
+; tags, and the rules below resolve that scope correctly without needing
+; injection.
+
+; -------------------------------------------------------------------------
+; Scopes
+; -------------------------------------------------------------------------
+
+; The whole document is the implicit top-level scope.
+(markup) @local.scope
+
+; Structural scopes inside tags — same rules as the code grammar.
+(function_declaration) @local.scope
+(function_expression) @local.scope
+(arrow_function) @local.scope
+; statement_block provides block scoping for let/const
+(statement_block) @local.scope
+; for loops scope their initialiser variable(s) to the loop body
+(for_statement) @local.scope
+(for_alt_statement) @local.scope
+(for_in_statement) @local.scope
+(for_in_alt_statement) @local.scope
+; catch clause scopes its parameter to the handler body
+(catch_clause) @local.scope
+
+; -------------------------------------------------------------------------
+; Definitions — functions
+; -------------------------------------------------------------------------
+
+; Function declaration names belong to the enclosing scope so that
+; callers outside the function body can resolve them.
+(function_declaration
+  name: (identifier) @local.definition.function
+  (#set! definition.function.scope parent))
+
+; Named function expressions keep their name inside the expression scope
+; (self-recursion only).
+(function_expression
+  name: (identifier) @local.definition.function)
+
+; -------------------------------------------------------------------------
+; Definitions — variables
+; -------------------------------------------------------------------------
+
+(variable_declarator
+  name: (identifier) @local.definition.var)
+
+; -------------------------------------------------------------------------
+; Definitions — parameters
+; -------------------------------------------------------------------------
+
+(formal_parameters (identifier) @local.definition.parameter)
+(rest_element (identifier) @local.definition.parameter)
+(arrow_function parameter: (identifier) @local.definition.parameter)
+
+; catch clause binding
+(catch_clause
+  parameter: (identifier) @local.definition.var)
+
+; -------------------------------------------------------------------------
+; Definitions — for-in loop variables
+;
+; Only capture when let/const is present (kind field exists).  A bare
+; `for (k in obj)` is an assignment to an existing variable, not a new
+; binding; tagging it as a definition would incorrectly shadow the outer `k`.
+; -------------------------------------------------------------------------
+
+(for_in_statement
+  kind: _
+  left: (identifier) @local.definition.var)
+(for_in_statement
+  kind: _
+  value: (identifier) @local.definition.var)
+(for_in_alt_statement
+  kind: _
+  left: (identifier) @local.definition.var)
+(for_in_alt_statement
+  kind: _
+  value: (identifier) @local.definition.var)
+
+; -------------------------------------------------------------------------
+; Definitions — imports
+; -------------------------------------------------------------------------
+
+; import def from "./mod.uc"
+(import_clause (identifier) @local.definition.import)
+
+; import * as ns from "./mod.uc"
+(namespace_import (identifier) @local.definition.import)
+
+; import { a } from "./mod.uc"  — name IS the local binding (no alias)
+(import_specifier
+  name: (identifier) @local.definition.import
+  !alias)
+
+; import { a as x } from "./mod.uc"  — only the alias is the local binding
+(import_specifier
+  alias: (identifier) @local.definition.import)
+
+; -------------------------------------------------------------------------
+; References
+; -------------------------------------------------------------------------
+
+(identifier) @local.reference

package/markup/queries/tags.scm

@@ -0,0 +1,65 @@
+; Tags queries for ucode_markup.
+; The markup grammar produces a unified tree — function declarations and
+; other named symbols inside {% %} tags are real AST nodes, so the same
+; patterns as the code grammar apply here.
+
+(
+  (comment)* @doc
+  .
+  (function_declaration
+    name: (identifier) @name) @definition.function
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.function)
+)
+
+(
+  (comment)* @doc
+  .
+  (function_expression
+    name: (identifier) @name) @definition.function
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.function)
+)
+
+(
+  (comment)* @doc
+  .
+  (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: [(function_expression) (arrow_function)])) @definition.function
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.function)
+)
+
+(assignment_expression
+  left: [
+    (identifier) @name
+    (member_expression
+      property: (property_identifier) @name)
+  ]
+  right: [(function_expression) (arrow_function)]) @definition.function
+
+(pair
+  key: (property_identifier) @name
+  value: [(function_expression) (arrow_function)]) @definition.function
+
+(export_statement
+  (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: [
+        (number) (string) (true) (false) (null)
+        (identifier) (binary_expression) (call_expression)
+      ])) @definition.constant)
+
+(
+  (call_expression
+    function: (identifier) @name) @reference.call
+  (#not-match? @name "^(require|include|render)$")
+)
+
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @name)
+  arguments: (_) @reference.call)

package/markup/queries/textobjects.scm

@@ -0,0 +1,56 @@
+; Text-object queries for ucode_markup.
+; Code nodes inside {% %} tags are real AST nodes in the unified tree,
+; so the same patterns as the code grammar apply here.
+
+; ── Functions ─────────────────────────────────────────────────────────────────
+
+(function_declaration
+  body: (statement_block) @function.inner) @function.outer
+
+(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
+  body: (expression) @function.inner) @function.outer
+
+; ── Parameters ────────────────────────────────────────────────────────────────
+
+(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 ────────────────────────────────────────────────────────────────────
+
+(statement_block) @block.outer
+(statement_block (_) @block.inner)