rapydscript-ng 0.7.24 → 0.8.1

package/tree-sitter/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "tree-sitter-rapydscript",
+  "version": "0.1.0",
+  "description": "RapydScript grammar for tree-sitter",
+  "main": "bindings/node",
+  "keywords": [
+    "parser",
+    "lexer",
+    "rapydscript",
+    "tree-sitter"
+  ],
+  "license": "BSD-2-Clause",
+  "dependencies": {
+    "node-addon-api": "^8.0.0",
+    "node-gyp-build": "^4.8.0"
+  },
+  "peerDependencies": {
+    "tree-sitter": "^0.21.0"
+  },
+  "peerDependenciesMeta": {
+    "tree-sitter": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "tree-sitter-cli": "^0.26.0"
+  },
+  "scripts": {
+    "generate": "tree-sitter generate",
+    "test": "tree-sitter test"
+  },
+  "tree-sitter": [
+    {
+      "scope": "source.rapydscript",
+      "file-types": [
+        "pyj"
+      ],
+      "highlights": [
+        "queries/highlights.scm"
+      ]
+    }
+  ]
+}

package/tree-sitter/queries/highlights.scm

@@ -0,0 +1,232 @@
+; Syntax highlighting for RapydScript
+; Capture names follow the nvim-treesitter conventions so this file works
+; out-of-the-box in Neovim. More specific patterns come later so that they
+; override the more general ones.
+
+; ----------------------------------------------------------------------------
+; Identifiers
+; ----------------------------------------------------------------------------
+
+(identifier) @variable
+
+; ----------------------------------------------------------------------------
+; Literals
+; ----------------------------------------------------------------------------
+
+(comment) @comment @spell
+
+(string) @string
+(verbatim) @string.special
+(concatenated_string) @string
+(regex) @string.regexp
+(number) @number
+
+(true) @boolean
+(false) @boolean
+(none) @constant.builtin
+(this) @variable.builtin
+
+; ----------------------------------------------------------------------------
+; Function & class definitions
+; ----------------------------------------------------------------------------
+
+(function_definition
+  name: (identifier) @function)
+
+(async_function_definition
+  name: (identifier) @function)
+
+(class_definition
+  name: (identifier) @type)
+
+(anonymous_function) @function
+
+; parameters
+(parameters (identifier) @variable.parameter)
+(typed_parameter name: (identifier) @variable.parameter)
+(default_parameter name: (identifier) @variable.parameter)
+(typed_default_parameter name: (identifier) @variable.parameter)
+(list_splat_parameter name: (identifier) @variable.parameter)
+(dictionary_splat_parameter name: (identifier) @variable.parameter)
+
+(typed_parameter type: (identifier) @type)
+(typed_default_parameter type: (identifier) @type)
+
+; ----------------------------------------------------------------------------
+; Calls
+; ----------------------------------------------------------------------------
+
+(call
+  function: (identifier) @function.call)
+
+(call
+  function: (attribute
+    attribute: (identifier) @function.method.call))
+
+(new_expression
+  constructor: (identifier) @type)
+
+(decorator) @attribute
+(decorator "@" @attribute)
+
+; keyword arguments
+(keyword_argument
+  name: (identifier) @variable.parameter)
+
+; attribute access
+(attribute
+  attribute: (identifier) @property)
+
+; ----------------------------------------------------------------------------
+; Keywords
+; ----------------------------------------------------------------------------
+
+[
+  "def"
+  "class"
+  "async"
+] @keyword.function
+
+[
+  "return"
+  "yield"
+  "raise"
+  "del"
+  "assert"
+  "global"
+  "nonlocal"
+] @keyword
+
+; single-token statements (their keyword is not separately queryable)
+[
+  (pass_statement)
+  (break_statement)
+  (continue_statement)
+  (debugger_statement)
+] @keyword
+
+[
+  "if"
+  "elif"
+  "else"
+] @keyword.conditional
+
+(conditional_expression ["if" "else"] @keyword.conditional.ternary)
+
+[
+  "for"
+  "while"
+  "do"
+] @keyword.repeat
+
+[
+  "try"
+  "except"
+  "finally"
+] @keyword.exception
+
+[
+  "import"
+  "from"
+  "as"
+  "with"
+] @keyword.import
+
+"await" @keyword.coroutine
+(yield "from" @keyword)
+
+[
+  "and"
+  "or"
+  "not"
+  "in"
+  "is"
+  "new"
+  "typeof"
+  "void"
+  "instanceof"
+] @keyword.operator
+
+; ----------------------------------------------------------------------------
+; Operators & punctuation
+; ----------------------------------------------------------------------------
+
+[
+  "+"
+  "-"
+  "*"
+  "/"
+  "//"
+  "%"
+  "**"
+  "="
+  "+="
+  "-="
+  "*="
+  "/="
+  "//="
+  "%="
+  "**="
+  "&="
+  "^="
+  "|="
+  ">>="
+  "<<="
+  ">>>="
+  "=="
+  "==="
+  "!="
+  "!=="
+  "<"
+  ">"
+  "<="
+  ">="
+  "&"
+  "|"
+  "^"
+  "~"
+  "<<"
+  ">>"
+  ">>>"
+  "->"
+  "?"
+  "@"
+] @operator
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  ","
+  ":"
+  "."
+  ";"
+] @punctuation.delimiter
+
+; ----------------------------------------------------------------------------
+; Builtins (common RapydScript / JavaScript globals)
+; ----------------------------------------------------------------------------
+
+((identifier) @constant.builtin
+  (#any-of? @constant.builtin "undefined" "NaN" "Infinity"))
+
+((identifier) @variable.builtin
+  (#any-of? @variable.builtin "self" "arguments" "window" "document" "console"))
+
+((identifier) @function.builtin
+  (#any-of? @function.builtin
+    "print" "len" "range" "enumerate" "list" "dict" "set" "str" "int" "float"
+    "bool" "isinstance" "getattr" "setattr" "hasattr" "iter" "type" "abs"
+    "min" "max" "sum" "sorted" "map" "filter" "zip" "repr" "jstype"))
+
+((identifier) @type.builtin
+  (#any-of? @type.builtin
+    "Object" "Array" "String" "Number" "Boolean" "RegExp" "Date" "Error"
+    "Exception" "TypeError" "ValueError" "KeyError" "IndexError" "Promise"
+    "Map" "Set" "WeakMap" "WeakSet" "Image" "Symbol"))

package/tree-sitter/queries/indents.scm

@@ -0,0 +1,64 @@
+; Smart indentation for RapydScript (nvim-treesitter indent queries).
+;
+; @indent.begin  — node whose body should be indented one level
+; @indent.end    — node that closes an indent region (closing brackets)
+; @indent.branch — keyword that sits at the same level as its opener
+;                  (elif/else/except/finally)
+; @indent.align  — opening bracket for alignment-based indent
+
+; ---------------------------------------------------------------------------
+; Compound statements that introduce an indented block
+; ---------------------------------------------------------------------------
+
+[
+  (function_definition)
+  (async_function_definition)
+  (class_definition)
+  (if_statement)
+  (while_statement)
+  (for_statement)
+  (for_js_statement)
+  (do_statement)
+  (try_statement)
+  (with_statement)
+  (decorated_definition)
+  (anonymous_function)
+  (block_tailed_statement)
+  (block)
+] @indent.begin
+
+; ---------------------------------------------------------------------------
+; Continuation clauses — dedent back to the level of the opening keyword
+; ---------------------------------------------------------------------------
+
+(elif_clause) @indent.branch
+(else_clause) @indent.branch
+(except_clause) @indent.branch
+(finally_clause) @indent.branch
+
+; do { ... } .while — the trailing ".while" is at statement level
+(do_statement "." @indent.branch)
+
+; ---------------------------------------------------------------------------
+; Bracket-delimited containers — alignment / one-level indent inside
+; ---------------------------------------------------------------------------
+
+[
+  (argument_list)
+  (parameters)
+  (list)
+  (tuple)
+  (set)
+  (dictionary)
+  (list_comprehension)
+  (set_comprehension)
+  (dictionary_comprehension)
+  (generator_expression)
+  (parenthesized_expression)
+] @indent.begin
+
+[
+  ")"
+  "]"
+  "}"
+] @indent.end

package/tree-sitter/queries/injections.scm

@@ -0,0 +1,14 @@
+; Language injections for RapydScript
+; These let Neovim highlight embedded languages inside RapydScript source.
+
+; Verbatim JavaScript literals ( v'...' ) contain raw JavaScript.
+((verbatim) @injection.content
+  (#set! injection.language "javascript"))
+
+; Regular expression literals.
+((regex) @injection.content
+  (#set! injection.language "regex"))
+
+; Comments (for TODO/FIXME highlighting via the `comment` parser, if installed).
+((comment) @injection.content
+  (#set! injection.language "comment"))

package/tree-sitter/queries/locals.scm

@@ -0,0 +1,108 @@
+; Scope and definition tracking for RapydScript (nvim-treesitter locals queries).
+;
+; @local.scope       — node that introduces a new name scope
+; @local.definition  — an identifier being declared/bound in the current scope
+; @local.reference   — an identifier being looked up (read)
+
+; ---------------------------------------------------------------------------
+; Scopes
+; ---------------------------------------------------------------------------
+
+(module) @local.scope
+
+(function_definition) @local.scope
+(async_function_definition) @local.scope
+
+; Anonymous functions create their own closure scope (the key RapydScript feature)
+(anonymous_function) @local.scope
+(block_tailed_statement) @local.scope
+
+(class_definition) @local.scope
+
+; ---------------------------------------------------------------------------
+; Definitions
+; ---------------------------------------------------------------------------
+
+; Named function and class declarations
+(function_definition
+  name: (identifier) @local.definition)
+
+(async_function_definition
+  name: (identifier) @local.definition)
+
+(class_definition
+  name: (identifier) @local.definition)
+
+; Named anonymous function expression:  factorial = def named(n): ...
+(anonymous_function
+  name: (identifier) @local.definition)
+
+; Function parameters
+(parameters (identifier) @local.definition)
+(typed_parameter
+  name: (identifier) @local.definition)
+(default_parameter
+  name: (identifier) @local.definition)
+(typed_default_parameter
+  name: (identifier) @local.definition)
+(list_splat_parameter
+  name: (identifier) @local.definition)
+(dictionary_splat_parameter
+  name: (identifier) @local.definition)
+
+; Assignment targets
+(assignment
+  left: (identifier) @local.definition)
+(assignment
+  left: (pattern_list (pattern (identifier) @local.definition)))
+(assignment
+  left: (pattern (tuple_pattern (pattern (identifier) @local.definition))))
+(assignment
+  left: (pattern (list_pattern (pattern (identifier) @local.definition))))
+
+; Augmented assignment also binds the target
+(augmented_assignment
+  left: (identifier) @local.definition)
+
+; For-loop variables
+(for_statement
+  left: (identifier) @local.definition)
+(for_statement
+  left: (pattern_list (pattern (identifier) @local.definition)))
+(for_in_clause
+  left: (identifier) @local.definition)
+(for_in_clause
+  left: (pattern_list (pattern (identifier) @local.definition)))
+
+; Import statements
+(import_statement
+  name: (dotted_name (identifier) @local.definition))
+
+(import_from_statement
+  name: (identifier) @local.definition)
+
+; `import foo as bar` — bar is the local name
+(aliased_import
+  alias: (identifier) @local.definition)
+
+; `from foo import baz as qux` — qux is the local name
+(aliased_import_name
+  alias: (identifier) @local.definition)
+
+; `with expr as alias:`
+(with_clause
+  alias: (identifier) @local.definition)
+
+; `except ExcType as e:`
+(except_clause
+  alias: (identifier) @local.definition)
+
+; global / nonlocal declarations — the identifier becomes visible in the scope
+(global_statement (identifier) @local.definition)
+(nonlocal_statement (identifier) @local.definition)
+
+; ---------------------------------------------------------------------------
+; References
+; ---------------------------------------------------------------------------
+
+(identifier) @local.reference