tree-sitter-ucode 0.1.0

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "tree-sitter-ucode",
+  "version": "0.1.0",
+  "description": "Ucode grammar for tree-sitter",
+  "repository": "https://github.com/m00qek/tree-sitter-ucode",
+  "license": "MIT",
+  "main": "bindings/node",
+  "types": "bindings/node",
+  "keywords": [
+    "incremental",
+    "parsing",
+    "tree-sitter",
+    "ucode",
+    "openwrt"
+  ],
+  "files": [
+    "grammar.js",
+    "tree-sitter.json",
+    "binding.gyp",
+    "prebuilds/**",
+    "bindings/node/*",
+    "queries/*",
+    "src/**",
+    "tmpl/grammar.js",
+    "tmpl/src/**",
+    "tmpl/queries/*",
+    "*.wasm"
+  ],
+  "dependencies": {
+    "node-addon-api": "^8.3.1",
+    "node-gyp-build": "^4.8.4"
+  },
+  "devDependencies": {
+    "prebuildify": "^6.0.1",
+    "tree-sitter-cli": "^0.26.0"
+  },
+  "peerDependencies": {
+    "tree-sitter": "^0.22.0"
+  },
+  "peerDependenciesMeta": {
+    "tree-sitter": {
+      "optional": true
+    }
+  },
+  "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",
+    "prestart": "tree-sitter build --wasm",
+    "start": "tree-sitter playground"
+  }
+}

package/queries/highlights.scm

@@ -0,0 +1,163 @@
+; Highlight queries for ucode.
+; Capture names follow the tree-sitter / nvim-treesitter standard.
+
+; -------------------------------------------------------------------------
+; Identifiers
+; -------------------------------------------------------------------------
+
+(identifier) @variable
+(property_identifier) @variable.member
+(shorthand_property_identifier) @variable.member
+(statement_identifier) @label
+
+; -------------------------------------------------------------------------
+; Built-in / special values
+; -------------------------------------------------------------------------
+
+(this) @variable.builtin
+[(true) (false)] @boolean
+(null) @constant.builtin
+
+; -------------------------------------------------------------------------
+; Comments
+; -------------------------------------------------------------------------
+
+(comment) @comment @spell
+
+; -------------------------------------------------------------------------
+; Shebang
+; -------------------------------------------------------------------------
+
+(hash_bang_line) @keyword.directive
+
+; -------------------------------------------------------------------------
+; Literals
+; -------------------------------------------------------------------------
+
+(number) @number
+
+(string) @string
+(string (escape_sequence) @string.escape)
+
+(template_string) @string
+(template_string (escape_sequence) @string.escape)
+(template_substitution "${" @punctuation.special)
+(template_substitution "}" @punctuation.special)
+
+(regex) @string.regexp
+
+; -------------------------------------------------------------------------
+; Functions — definitions
+; -------------------------------------------------------------------------
+
+(function_declaration
+  name: (identifier) @function)
+
+(function_forward_declaration
+  name: (identifier) @function)
+
+(function_expression
+  name: (identifier) @function)
+
+; Method-style object entries: { key: function() {} }  or  { key: () => {} }
+(pair
+  key: (property_identifier) @function.method
+  value: [(function_expression) (arrow_function)])
+
+; -------------------------------------------------------------------------
+; Functions — calls
+; -------------------------------------------------------------------------
+
+(call_expression
+  function: (identifier) @function.call)
+
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @function.method.call))
+
+; -------------------------------------------------------------------------
+; Parameters
+; -------------------------------------------------------------------------
+
+(formal_parameters (identifier) @variable.parameter)
+(rest_element (identifier) @variable.parameter)
+(arrow_function parameter: (identifier) @variable.parameter)
+
+; -------------------------------------------------------------------------
+; Keywords — conditional
+; -------------------------------------------------------------------------
+
+["if" "elif" "else" "endif"] @keyword.conditional
+["switch" "case" "default"] @keyword.conditional
+
+; -------------------------------------------------------------------------
+; Keywords — loops
+; -------------------------------------------------------------------------
+
+["for" "endfor" "while" "endwhile"] @keyword.repeat
+
+; -------------------------------------------------------------------------
+; Keywords — functions
+; -------------------------------------------------------------------------
+
+["function" "endfunction"] @keyword.function
+
+; -------------------------------------------------------------------------
+; Keywords — control
+; -------------------------------------------------------------------------
+
+"return" @keyword.return
+["break" "continue"] @keyword
+
+; -------------------------------------------------------------------------
+; Keywords — exceptions
+; -------------------------------------------------------------------------
+
+["try" "catch"] @keyword.exception
+
+; -------------------------------------------------------------------------
+; Keywords — modules
+; -------------------------------------------------------------------------
+
+["import" "export"] @keyword.import
+["as" "from"] @keyword.import
+; Dynamic import() uses a named node, not an anonymous string
+(import_expression (import) @keyword.import)
+
+; -------------------------------------------------------------------------
+; Keywords — storage / operators
+; -------------------------------------------------------------------------
+
+["const" "let"] @keyword.storage
+["delete" "in"] @keyword.operator
+
+; -------------------------------------------------------------------------
+; Operators
+; -------------------------------------------------------------------------
+
+[
+  "=" "+=" "-=" "*=" "/=" "%=" "**="
+  "^=" "&=" "|=" ">>=" "<<=" "&&=" "||=" "??="
+] @operator
+
+[
+  "+" "-" "*" "/" "%" "**"
+  "&" "|" "^" "~" "<<" ">>"
+  "!" "&&" "||" "??"
+  "==" "!=" "===" "!=="
+  "<" ">" "<=" ">="
+  "++" "--"
+  "=>"
+  "..."
+] @operator
+
+(optional_chain) @operator
+(ternary_expression "?" @operator)
+(ternary_expression ":" @operator)
+
+; -------------------------------------------------------------------------
+; Punctuation
+; -------------------------------------------------------------------------
+
+["," ";"] @punctuation.delimiter
+["(" ")" "[" "]" "{" "}"] @punctuation.bracket

package/queries/locals.scm

@@ -0,0 +1,105 @@
+; Locals queries for ucode.
+; Used by editors for rename, go-to-definition, and scope-aware highlight.
+
+; -------------------------------------------------------------------------
+; Scopes
+; -------------------------------------------------------------------------
+
+(function_declaration) @local.scope
+; function_forward_declaration has no body — it is a definition, not a 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
+; -------------------------------------------------------------------------
+
+; Declaration and forward-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))
+
+(function_forward_declaration
+  name: (identifier) @local.definition.function
+  (#set! definition.function.scope parent))
+
+; Named function expressions (let f = function foo() {}) keep their name
+; *inside* the expression scope — foo is only visible for self-recursion,
+; not to the surrounding block.  No (#set! parent) here.
+(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/queries/tags.scm

@@ -0,0 +1,104 @@
+; Tags queries for ucode.
+; Used by GitHub code navigation and tools that index symbol definitions.
+
+; -------------------------------------------------------------------------
+; Function definitions — named declarations (brace body or endfunction body)
+; -------------------------------------------------------------------------
+
+(
+  (comment)* @doc
+  .
+  (function_declaration
+    name: (identifier) @name) @definition.function
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.function)
+)
+
+; -------------------------------------------------------------------------
+; Function definitions — forward declarations: `function name;`
+; -------------------------------------------------------------------------
+
+(
+  (comment)* @doc
+  .
+  (function_forward_declaration
+    name: (identifier) @name) @definition.function
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.function)
+)
+
+; -------------------------------------------------------------------------
+; Function definitions — named function expressions
+; -------------------------------------------------------------------------
+
+(
+  (comment)* @doc
+  .
+  (function_expression
+    name: (identifier) @name) @definition.function
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.function)
+)
+
+; -------------------------------------------------------------------------
+; Function definitions — let/const assigned a function or arrow
+; -------------------------------------------------------------------------
+
+(
+  (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)
+)
+
+; -------------------------------------------------------------------------
+; Function definitions — assignment of function to variable or property
+; -------------------------------------------------------------------------
+
+(assignment_expression
+  left: [
+    (identifier) @name
+    (member_expression
+      property: (property_identifier) @name)
+  ]
+  right: [(function_expression) (arrow_function)]) @definition.function
+
+; -------------------------------------------------------------------------
+; Function definitions — object method pairs  { key: function() {} }
+; -------------------------------------------------------------------------
+
+(pair
+  key: (property_identifier) @name
+  value: [(function_expression) (arrow_function)]) @definition.function
+
+; -------------------------------------------------------------------------
+; Constants — exported scalar / expression values
+; -------------------------------------------------------------------------
+
+(export_statement
+  (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: [
+        (number) (string) (true) (false) (null)
+        (identifier) (binary_expression) (call_expression)
+      ])) @definition.constant)
+
+; -------------------------------------------------------------------------
+; References — function calls
+; -------------------------------------------------------------------------
+
+(
+  (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)