tree-sitter-matlab 1.2.9__cp310-abi3-musllinux_1_2_i686.whl

tree_sitter_matlab/__init__.py

@@ -0,0 +1,42 @@
+"""MATLAB tree-sitter parser"""
+
+from importlib.resources import files as _files
+
+from ._binding import language
+
+
+def _get_query(name, file):
+    query = _files(f"{__package__}.queries") / file
+    globals()[name] = query.read_text()
+    return globals()[name]
+
+
+def __getattr__(name):
+    # NOTE: uncomment these to include any queries that this grammar contains:
+
+    # if name == "HIGHLIGHTS_QUERY":
+    #     return _get_query("HIGHLIGHTS_QUERY", "highlights.scm")
+    # if name == "INJECTIONS_QUERY":
+    #     return _get_query("INJECTIONS_QUERY", "injections.scm")
+    # if name == "LOCALS_QUERY":
+    #     return _get_query("LOCALS_QUERY", "locals.scm")
+    # if name == "TAGS_QUERY":
+    #     return _get_query("TAGS_QUERY", "tags.scm")
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = [
+    "language",
+    # "HIGHLIGHTS_QUERY",
+    # "INJECTIONS_QUERY",
+    # "LOCALS_QUERY",
+    # "TAGS_QUERY",
+]
+
+
+def __dir__():
+    return sorted(__all__ + [
+        "__all__", "__builtins__", "__cached__", "__doc__", "__file__",
+        "__loader__", "__name__", "__package__", "__path__", "__spec__",
+    ])

tree_sitter_matlab/__init__.pyi

@@ -0,0 +1,10 @@
+from typing import Final
+
+# NOTE: uncomment these to include any queries that this grammar contains:
+
+# HIGHLIGHTS_QUERY: Final[str]
+# INJECTIONS_QUERY: Final[str]
+# LOCALS_QUERY: Final[str]
+# TAGS_QUERY: Final[str]
+
+def language() -> object: ...

tree_sitter_matlab/binding.c

@@ -0,0 +1,35 @@
+#include <Python.h>
+
+typedef struct TSLanguage TSLanguage;
+
+TSLanguage *tree_sitter_matlab(void);
+
+static PyObject* _binding_language(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(args)) {
+    return PyCapsule_New(tree_sitter_matlab(), "tree_sitter.Language", NULL);
+}
+
+static struct PyModuleDef_Slot slots[] = {
+#ifdef Py_GIL_DISABLED
+    {Py_mod_gil, Py_MOD_GIL_NOT_USED},
+#endif
+    {0, NULL}
+};
+
+static PyMethodDef methods[] = {
+    {"language", _binding_language, METH_NOARGS,
+     "Get the tree-sitter language for this grammar."},
+    {NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef module = {
+    .m_base = PyModuleDef_HEAD_INIT,
+    .m_name = "_binding",
+    .m_doc = NULL,
+    .m_size = 0,
+    .m_methods = methods,
+    .m_slots = slots,
+};
+
+PyMODINIT_FUNC PyInit__binding(void) {
+    return PyModuleDef_Init(&module);
+}

tree_sitter_matlab/queries/emacs/highlights.scm

@@ -0,0 +1,176 @@
+; attribute
+; comment
+; constant
+; constant.builtin
+; constructor
+; doc
+; embedded
+; escape
+; function
+; function.builtin
+; function.call
+; function.macro
+; function.special
+; keyword
+; label
+; method
+; method.call
+; number
+; operator
+; property
+; property.definition
+; punctuation
+; punctuation.bracket
+; punctuation.delimiter
+; punctuation.special
+; string
+; string.special
+; tag
+; type
+; type.argument
+; type.builtin
+; type.parameter
+; type.super
+; variable
+; variable.builtin
+; variable.parameter
+; variable.special
+
+; Errors
+
+(ERROR) @error
+
+; Constants
+
+(events (identifier) @constant)
+(attribute (identifier) @constant)
+
+"~" @constant.builtin
+
+; Fields/Properties
+
+(field_expression field: (identifier) @property)
+(superclass "." (identifier) @property)
+(property_name "." (identifier) @property)
+(property name: (identifier) @property)
+
+; Types
+
+(class_definition name: (identifier) @type)
+(attributes (identifier) @constant)
+(enum . (identifier) @type)
+
+; Functions
+
+(function_definition
+  "function" @keyword
+  name: (identifier) @function
+  [ "end" "endfunction" ]? @keyword)
+
+(function_signature name: (identifier) @function)
+
+(function_call name: (identifier) @function.call)
+
+(handle_operator (identifier) @function)
+(validation_functions (identifier) @function)
+
+(command (command_name) @function.macro)
+(command_argument) @string
+
+(return_statement) @keyword
+
+; Parameters
+
+(lambda (arguments (identifier) @variable.parameter))
+(function_arguments (identifier) @variable.parameter)
+
+; Conditionals
+
+(if_statement [ "if" "end" ] @keyword)
+(elseif_clause "elseif" @keyword)
+(else_clause "else" @keyword)
+(switch_statement [ "switch" "end" ] @keyword)
+(case_clause "case" @keyword)
+(otherwise_clause "otherwise" @keyword)
+(break_statement) @keyword
+
+; Repeats
+
+(for_statement [ "for" "parfor" "end" ] @keyword)
+(while_statement [ "while" "end" ] @keyword)
+(continue_statement) @keyword
+
+; Exceptions
+
+(try_statement [ "try" "end" ] @keyword)
+(catch_clause "catch" @keyword)
+
+; Punctuation
+
+[ ";" "," "." ] @punctuation.delimiter
+[ "(" ")" "[" "]" "{" "}" ] @punctuation.bracket
+
+; Literals
+
+(escape_sequence) @escape
+(formatting_sequence) @escape
+(string) @string
+(number) @number
+
+; Comments
+
+[ (comment) (line_continuation) ] @comment @spell
+
+; Operators
+
+(unary_operator ["+" "-"] @number)
+
+[
+  "+"
+  ".+"
+  "-"
+  ".*"
+  "*"
+  ".*"
+  "/"
+  "./"
+  "\\"
+  ".\\"
+  "^"
+  ".^"
+  "'"
+  ".'"
+  "|"
+  "&"
+  "?"
+  "@"
+  "<"
+  "<="
+  ">"
+  ">="
+  "=="
+  "~="
+  "="
+  "&&"
+  "||"
+  ":"
+] @operator
+
+; Assignments
+
+(assignment left: (_) @variable)
+(multioutput_variable (_) @variable)
+
+; Keywords
+
+[
+  "arguments"
+  "classdef"
+  "end"
+  "enumeration"
+  "events"
+  "global"
+  "methods"
+  "persistent"
+  "properties"
+] @keyword

tree_sitter_matlab/queries/emacs/textobjects.scm

@@ -0,0 +1,93 @@
+(_ (block) @block.inner) @block.outer
+(block (_) @statement.outer)
+(source_file (_) @statement.outer)
+
+(function_call
+  (arguments)? @call.inner) @call.outer
+((arguments ","? @parameter.outer._start . (_) @parameter.outer._end @parameter.inner . ))
+((arguments (_) @parameter.outer._start @parameter.inner . "," @parameter.outer._end))
+
+(command) @call.outer
+(command (command_argument) @parameter.inner @parameter.outer)
+(command
+  (command_argument) @call.inner._start (command_argument)* @call.inner._end .)
+
+(if_statement
+  (block) @conditional.inner) @conditional.outer
+(if_statement
+  (elseif_clause
+    (block) @conditional.inner))
+(if_statement
+  (else_clause
+    (block) @conditional.inner))
+
+(switch_statement
+  (case_clause (block) @conditional.inner)) @conditional.outer
+
+(switch_statement
+  (otherwise_clause (block) @conditional.inner))
+
+(for_statement
+  (block) @loop.inner) @loop.outer
+(while_statement
+  (block) @loop.inner) @loop.outer
+
+(lambda
+  expression: (_) @function.inner) @function.outer
+
+(global_operator
+  (identifier) @parameter.inner)
+
+(persistent_operator
+  (identifier) @parameter.inner)
+
+(function_definition
+  (block) @function.inner) @function.outer
+
+(function_output (identifier) @parameter.inner @parameter.outer)
+
+((multioutput_variable ","? @parameter.outer._start . (_) @parameter.outer._end @parameter.inner . ))
+((multioutput_variable (_) @parameter.inner @parameter.outer._start . "," @parameter.outer._end))
+
+((function_arguments ","? @parameter.outer._start . (_) @parameter.inner._end @parameter.inner . ))
+((function_arguments (_) @parameter.outer._start @parameter.inner . "," @parameter.outer._end))
+
+(try_statement
+  (block) @conditional.inner) @conditional.outer
+(catch_clause
+  (identifier) @parameter.inner @parameter.outer)
+(catch_clause
+  (block) @conditional.inner)
+
+(class_definition) @class.outer
+
+(number) @number.inner
+(_ (return_statement) @return.inner @return.outer)
+(comment) @comment.outer
+
+(matrix (row) @parameter.outer)
+(cell (row) @parameter.outer)
+(row (_) @parameter.inner)
+
+(assignment
+  left: (_) @assignment.lhs
+  (_) @assignment.rhs) @assignment.outer
+
+((superclasses "&"? @parameter.outer._start . (_) @parameter.inner @parameter.outer._end . ))
+((superclasses (_) @parameter.inner @parameter.outer._start . "&" @parameter.outer._end))
+
+(enum (identifier) @parameter.inner @parameter.outer)
+
+(property name: (_) @parameter.outer @parameter.inner)
+
+((enum ","? @parameter.outer._start . (_) @parameter.inner @parameter.outer._end . ))
+((enum (_) @parameter.inner @parameter.outer._start . "," @parameter.outer._end))
+
+((validation_functions ","? @paramenter.outer._start . (_) @parameter.inner @parameter.outer._end . ))
+((validation_functions (_) @paramter.outer._start @parameter.inner . "," @parameter.outer._end))
+
+((dimensions ","? @parameter.outer._start @_start . (_) @parameter.inner @parameter.outer._end . ))
+((dimensions (_) @parameter.outer._start @parameter.inner . "," @parameter.outer._end))
+
+((attributes ","? @parameter.outer._start . (_) @parameter.inner @parameter.outer._end . ))
+((attributes (_) @parameter.outer._start @parameter.inner . "," @parameter.outer._end))

tree_sitter_matlab/queries/helix/context.scm

@@ -0,0 +1,41 @@
+(function_definition
+  (block (_) @context.end)
+) @context
+
+(while_statement
+  (block (_) @context.end)
+) @context
+
+(for_statement
+  (block (_) @context.end)
+) @context
+
+(if_statement
+  (block (_) @context.end)
+) @context
+
+(elseif_clause
+  (block (_) @context.end)
+) @context
+
+(else_clause
+  (block (_) @context.end)
+) @context
+
+(switch_statement) @context
+
+(case_clause
+  (block (_) @context.end)
+) @context
+
+(otherwise_clause
+  (block (_) @context.end)
+) @context
+
+(try_statement
+  "try"
+  (block (_) @context.end) @context
+  "end")
+(catch_clause
+  "catch"
+  (block (_) @context.end) @context)

tree_sitter_matlab/queries/helix/folds.scm

@@ -0,0 +1,11 @@
+[(if_statement)
+ (for_statement)
+ (while_statement)
+ (switch_statement)
+ (try_statement)
+ (function_definition)
+ (class_definition)
+ (enumeration)
+ (events)
+ (methods)
+ (properties)] @fold

tree_sitter_matlab/queries/helix/highlights.scm

@@ -0,0 +1,127 @@
+; Constants
+
+(events (identifier) @constant)
+(attribute (identifier) @constant)
+
+"~" @constant.builtin
+
+; Fields/Properties
+
+(superclass "." (identifier) @variable.other.member)
+(property_name "." (identifier) @variable.other.member)
+(property name: (identifier) @variable.other.member)
+
+; Types
+
+(class_definition name: (identifier) @keyword.storage.type)
+(attributes (identifier) @constant)
+(enum . (identifier) @type.enum.variant)
+
+; Functions
+
+(function_definition
+  "function" @keyword.function
+  name: (identifier) @function
+  [ "end" "endfunction" ]? @keyword.function)
+
+(function_signature name: (identifier) @function)
+(function_call name: (identifier) @function)
+(handle_operator (identifier) @function)
+(validation_functions (identifier) @function)
+(command (command_name) @function.macro)
+(command_argument) @string
+(return_statement) @keyword.control.return
+
+; Assignments
+
+(assignment left: (_) @variable)
+(multioutput_variable (_) @variable)
+
+; Parameters
+
+(function_arguments (identifier) @variable.parameter)
+
+; Conditionals
+
+(if_statement [ "if" "end" ] @keyword.control.conditional)
+(elseif_clause "elseif" @keyword.control.conditional)
+(else_clause "else" @keyword.control.conditional)
+(switch_statement [ "switch" "end" ] @keyword.control.conditional)
+(case_clause "case" @keyword.control.conditional)
+(otherwise_clause "otherwise" @keyword.control.conditional)
+(break_statement) @keyword.control.conditional
+
+; Repeats
+
+(for_statement [ "for" "parfor" "end" ] @keyword.control.repeat)
+(while_statement [ "while" "end" ] @keyword.control.repeat)
+(continue_statement) @keyword.control.repeat
+
+; Exceptions
+
+(try_statement [ "try" "end" ] @keyword.control.exception)
+(catch_clause "catch" @keyword.control.exception)
+
+; Punctuation
+
+[ ";" "," "." ] @punctuation.delimiter
+[ "(" ")" "[" "]" "{" "}" ] @punctuation.bracket
+
+; Literals
+
+(escape_sequence) @constant.character.escape
+(formatting_sequence) @constant.character.escape
+(string) @string
+(number) @constant.numeric.float
+(unary_operator ["+" "-"] @constant.numeric.float)
+
+; Comments
+
+[ (comment) (line_continuation) ] @comment.line
+
+; Operators
+
+[
+  "+"
+  ".+"
+  "-"
+  ".*"
+  "*"
+  ".*"
+  "/"
+  "./"
+  "\\"
+  ".\\"
+  "^"
+  ".^"
+  "'"
+  ".'"
+  "|"
+  "&"
+  "?"
+  "@"
+  "<"
+  "<="
+  ">"
+  ">="
+  "=="
+  "~="
+  "="
+  "&&"
+  "||"
+  ":"
+] @operator
+
+; Keywords
+
+"classdef" @keyword.storage.type
+[
+  "arguments"
+  "end"
+  "enumeration"
+  "events"
+  "global"
+  "methods"
+  "persistent"
+  "properties"
+] @keyword

tree_sitter_matlab/queries/helix/indents.scm

@@ -0,0 +1,24 @@
+[
+  (arguments_statement)
+  (if_statement)
+  (for_statement)
+  (while_statement)
+  (switch_statement)
+  (try_statement)
+  (function_definition)
+  (class_definition)
+  (enumeration)
+  (events)
+  (methods)
+  (properties)
+] @indent
+
+[
+  (elseif_clause)
+  (else_clause)
+  (case_clause)
+  (otherwise_clause)
+  (catch_clause)
+] @indent @extend
+
+[ "end" ] @outdent

tree_sitter_matlab/queries/helix/injections.scm

@@ -0,0 +1,2 @@
+((comment) @injection.content
+ (#set! injection.language "comment"))

tree_sitter_matlab/queries/helix/locals.scm

@@ -0,0 +1,19 @@
+(function_definition name: (identifier) @local.definition ?) @local.scope
+(function_arguments (identifier)* @local.definition)
+
+(lambda (arguments (identifier) @local.definition)) @local.scope
+
+(assignment left: ((function_call
+                     name: (identifier) @local.definition)))
+(assignment left: ((field_expression . [(function_call
+                                          name: (identifier) @local.definition)
+                                        (identifier) @local.definition])))
+(assignment left: (_) @local.definition)
+(assignment (multioutput_variable (_) @local.definition))
+
+(iterator . (identifier) @local.definition)
+(global_operator (identifier) @local.definition)
+(persistent_operator (identifier) @local.definition)
+(catch_clause (identifier) @local.definition)
+
+(identifier) @local.reference

tree_sitter_matlab/queries/helix/textobjects.scm

@@ -0,0 +1,9 @@
+(arguments ((_) @parameter.inside . ","? @parameter.around) @parameter.around)
+(function_arguments ((_) @parameter.inside . ","? @parameter.around) @parameter.around)
+
+(lambda expression: (_) @function.inside) @function.around
+(function_definition (block) @function.inside) @function.around
+
+(class_definition) @class.inside @class.around
+
+(comment) @comment.inside @comment.around

tree_sitter_matlab/queries/neovim/context.scm

@@ -0,0 +1,41 @@
+(function_definition
+  (block (_) @context.end)
+) @context
+
+(while_statement
+  (block (_) @context.end)
+) @context
+
+(for_statement
+  (block (_) @context.end)
+) @context
+
+(if_statement
+  (block (_) @context.end)
+) @context
+
+(elseif_clause
+  (block (_) @context.end)
+) @context
+
+(else_clause
+  (block (_) @context.end)
+) @context
+
+(switch_statement) @context
+
+(case_clause
+  (block (_) @context.end)
+) @context
+
+(otherwise_clause
+  (block (_) @context.end)
+) @context
+
+(try_statement
+  "try"
+  (block (_) @context.end) @context
+  "end")
+(catch_clause
+  "catch"
+  (block (_) @context.end) @context)

tree_sitter_matlab/queries/neovim/folds.scm

@@ -0,0 +1,11 @@
+[(if_statement)
+ (for_statement)
+ (while_statement)
+ (switch_statement)
+ (try_statement)
+ (function_definition)
+ (class_definition)
+ (enumeration)
+ (events)
+ (methods)
+ (properties)] @fold

tree_sitter_matlab/queries/neovim/highlights.scm

@@ -0,0 +1,157 @@
+; Includes
+
+((command_name) @include
+  (#eq? @include "import"))
+
+; Keywords
+
+[
+  "arguments"
+  "classdef"
+  "end"
+  "enumeration"
+  "events"
+  "global"
+  "methods"
+  "persistent"
+  "properties"
+] @keyword
+
+; Conditionals
+
+(if_statement [ "if" "end" ] @conditional)
+(elseif_clause "elseif" @conditional)
+(else_clause "else" @conditional)
+(switch_statement [ "switch" "end" ] @conditional)
+(case_clause "case" @conditional)
+(otherwise_clause "otherwise" @conditional)
+(break_statement) @conditional
+
+; Repeats
+
+(for_statement [ "for" "parfor" "end" ] @repeat)
+(while_statement [ "while" "end" ] @repeat)
+(continue_statement) @repeat
+
+; Exceptions
+
+(try_statement [ "try" "end" ] @exception)
+(catch_clause "catch" @exception)
+
+; Variables
+
+(identifier) @variable
+
+; Constants
+
+(events (identifier) @constant)
+(attribute (identifier) @constant)
+
+"~" @constant.builtin
+
+; Fields/Properties
+
+(field_expression field: (identifier) @field)
+
+(superclass "." (identifier) @property)
+
+(property_name "." (identifier) @property)
+
+(property name: (identifier) @property)
+
+; Types
+
+(class_definition name: (identifier) @type)
+
+(attributes (identifier) @constant)
+
+(enum . (identifier) @type)
+
+((identifier) @type
+  (#lua-match? @type "^_*[A-Z][a-zA-Z0-9_]+$"))
+
+; Functions
+
+(function_definition
+  "function" @keyword.function
+  name: (identifier) @function
+  [ "end" "endfunction" ]? @keyword.function)
+
+(function_signature name: (identifier) @function)
+
+(function_call
+  name: (identifier) @function.call)
+
+(handle_operator (identifier) @function)
+
+(validation_functions (identifier) @function)
+
+(command (command_name) @function.call)
+(command_argument) @parameter
+
+(return_statement) @keyword.return
+
+; Parameters
+
+(function_arguments (identifier) @parameter)
+
+; Punctuation
+
+[ ";" "," "." ] @punctuation.delimiter
+
+[ "(" ")" "[" "]" "{" "}" ] @punctuation.bracket
+
+; Operators
+
+[
+  "+"
+  ".+"
+  "-"
+  ".*"
+  "*"
+  ".*"
+  "/"
+  "./"
+  "\\"
+  ".\\"
+  "^"
+  ".^"
+  "'"
+  ".'"
+  "|"
+  "&"
+  "?"
+  "@"
+  "<"
+  "<="
+  ">"
+  ">="
+  "=="
+  "~="
+  "="
+  "&&"
+  "||"
+  ":"
+] @operator
+
+; Literals
+
+(string) @string
+
+(escape_sequence) @string.escape
+(formatting_sequence) @string.special
+
+(number) @number
+
+((identifier) @boolean
+  (#eq? @boolean "true"))
+((identifier) @boolean
+  (#eq? @boolean "false"))
+
+; Comments
+
+[ (comment) (line_continuation) ] @comment @spell
+
+; Errors
+
+(ERROR) @error

tree_sitter_matlab/queries/neovim/indents.scm

@@ -0,0 +1,36 @@
+"end" @indent.end @indent.branch
+
+[
+  (arguments_statement)
+  (if_statement)
+  (for_statement)
+  (while_statement)
+  (switch_statement)
+  (try_statement)
+  (function_definition)
+  (class_definition)
+  (enumeration)
+  (events)
+  (methods)
+  (properties)
+] @indent.begin
+
+[
+  "elseif"
+  "else"
+  "case"
+  "otherwise"
+  "catch"
+] @indent.branch
+
+((matrix (row) @indent.align)
+ (#set! indent.open_delimiter "[")
+ (#set! indent.close_delimiter "]"))
+((cell (row) @indent.align)
+ (#set! indent.open_delimiter "{")
+ (#set! indent.close_delimiter "}"))
+((parenthesis) @indent.align
+ (#set! indent.open_delimiter "(")
+ (#set! indent.close_delimiter ")"))
+
+(comment) @indent.auto

tree_sitter_matlab/queries/neovim/injections.scm

@@ -0,0 +1 @@
+(comment) @comment

tree_sitter_matlab/queries/neovim/locals.scm

@@ -0,0 +1,20 @@
+; References
+
+(identifier) @reference
+
+; Definitions
+
+(function_definition
+  name: (identifier) @definition.function
+  (function_arguments
+    (identifier)* @definition.parameter
+    ("," (identifier) @definition.parameter)*)?) @scope
+
+(assignment left: (identifier) @definition.var)
+(multioutput_variable (identifier) @definition.var)
+
+(iterator . (identifier) @definition.var)
+(lambda (arguments (identifier) @definition.parameter))
+(global_operator (identifier) @definition.var)
+(persistent_operator (identifier) @definition.var)
+(catch_clause (identifier) @definition)

tree_sitter_matlab/queries/neovim/tags.scm

@@ -0,0 +1,10 @@
+ (class_definition
+   name: (identifier) @name) @definition.class
+
+(function_definition
+  name: (identifier) @name) @definition.function
+
+(function_call
+  name: (identifier) @name) @reference.call
+
+(command (command_name) @name) @reference.call

tree_sitter_matlab/queries/neovim/textobjects.scm

@@ -0,0 +1,110 @@
+(_ (block) @block.inner) @block.outer
+(block (_) @statement.outer)
+(source_file (_) @statement.outer)
+
+(function_call
+  (arguments)? @call.inner) @call.outer
+((arguments ","? @_start . (_) @parameter.inner . )
+ (#make-range! "parameter.outer" @_start @parameter.inner))
+((arguments (_) @parameter.inner . "," @_end)
+ (#make-range! "parameter.outer" @parameter.inner @_end))
+
+(command) @call.outer
+(command (command_argument) @parameter.inner @parameter.outer)
+(command
+  (command_argument) @_start (command_argument)* @_end .
+  (#make-range! "call.inner" @_start @_end))
+
+(if_statement
+  (block) @conditional.inner) @conditional.outer
+(if_statement
+  (elseif_clause
+    (block) @conditional.inner))
+(if_statement
+  (else_clause
+    (block) @conditional.inner))
+
+(switch_statement
+  (case_clause (block) @conditional.inner)) @conditional.outer
+
+(switch_statement
+  (otherwise_clause (block) @conditional.inner))
+
+(for_statement
+  (block) @loop.inner) @loop.outer
+(while_statement
+  (block) @loop.inner) @loop.outer
+
+(lambda
+  expression: (_) @function.inner) @function.outer
+
+(global_operator
+  (identifier) @parameter.inner)
+
+(persistent_operator
+  (identifier) @parameter.inner)
+
+(function_definition
+  (block) @function.inner) @function.outer
+
+(function_output (identifier) @parameter.inner @parameter.outer)
+
+((function_arguments ","? @_start . (_) @parameter.inner . )
+ (#make-range! "parameter.outer" @_start @parameter.inner))
+((function_arguments (_) @parameter.inner . "," @_end)
+ (#make-range! "parameter.outer" @parameter.inner @_end))
+
+((multioutput_variable ","? @_start . (_) @parameter.inner . )
+ (#make-range! "parameter.outer" @_start @parameter.inner))
+((multioutput_variable (_) @parameter.inner . "," @_end)
+ (#make-range! "parameter.outer" @parameter.inner @_end))
+
+(try_statement
+  (block) @conditional.inner) @conditional.outer
+(catch_clause
+  (identifier) @parameter.inner @parameter.outer)
+(catch_clause
+  (block) @conditional.inner)
+
+(class_definition) @class.outer
+
+(number) @number.inner
+(_ (return_statement) @return.inner @return.outer)
+(comment) @comment.outer
+
+(matrix (row) @parameter.outer)
+(cell (row) @parameter.outer)
+(row (_) @parameter.inner)
+
+(assignment
+  left: (_) @assignment.lhs
+  (_) @assignment.rhs) @assignment.outer
+
+((superclasses "&"? @_start . (_) @parameter.inner . )
+ (#make-range! "parameter.outer" @_start @parameter.inner))
+((superclasses (_) @parameter.inner . "&" @_end)
+ (#make-range! "parameter.outer" @parameter.inner @_end))
+
+(enum (identifier) @parameter.inner @parameter.outer)
+
+(property name: (_) @parameter.outer @parameter.inner)
+
+((enum ","? @_start . (_) @parameter.inner . )
+ (#make-range! "parameter.outer" @_start @parameter.inner))
+((enum (_) @parameter.inner . "," @_end)
+ (#make-range! "parameter.outer" @parameter.inner @_end))
+
+((validation_functions ","? @_start . (_) @parameter.inner . )
+ (#make-range! "parameter.outer" @_start @parameter.inner))
+((validation_functions (_) @parameter.inner . "," @_end)
+ (#make-range! "parameter.outer" @parameter.inner @_end))
+
+((dimensions ","? @_start . (_) @parameter.inner . )
+ (#make-range! "parameter.outer" @_start @parameter.inner))
+((dimensions (_) @parameter.inner . "," @_end)
+ (#make-range! "parameter.outer" @parameter.inner @_end))
+
+((attributes ","? @_start . (_) @parameter.inner . )
+ (#make-range! "parameter.outer" @_start @parameter.inner))
+((attributes (_) @parameter.inner . "," @_end)
+ (#make-range! "parameter.outer" @parameter.inner @_end))

tree_sitter_matlab-1.2.9.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: tree-sitter-matlab
+Version: 1.2.9
+Summary: MATLAB tree-sitter parser
+Author: Álan Crístoffer e Sousa
+License: MIT
+Project-URL: Homepage, https://github.com/acristoffers/tree-sitter-matlab
+Keywords: incremental,parsing,tree-sitter,matlab
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: core
+Requires-Dist: tree-sitter~=0.24; extra == "core"
+Dynamic: license-file
+
+# MATLAB grammar for tree-sitter.
+
+There are screenshots at the end of this README :)
+
+This parser has the objective of generating a tree that is as correct as
+possible (but sometimes just convenient) with what MATLAB itself executes. It
+is not intended only for syntax highlight, but also to be used by scripts to
+whatever it may be needed. In fact, I wrote it because I'm a Neovim/Doom Emacs
+user and love having text-objects, and was really missing a text object for
+matrices rows/cells.
+
+Being as correct as possible means that some things are done correctly, for
+example:
+
+- Commands are parsed the same way MATLAB does it, by treating arguments as
+literals, grouping them correctly and only starting comments when allowed. It
+should perfectly match what MATLAB does.
+
+- Assignment has its own token, and multiple-variable assignment is NOT an
+assignment to a matrix (and returning an error is the correct thing to do, as
+it allows the user to see that something is off with the highlight, meaning
+something is probably off with the code):
+
+```matlab
+% (assignment (multioutput_variable (identifier) (identifier)) (identifier))
+[a,b] = d
+
+% this is WRONG:
+[a;b] = d
+```
+
+- Inside a matrix, `1 + 1` and `1 +1` are different things:
+
+```matlab
+a = 1 + 1 % 2
+a = 1 +1 %2
+[1 + 1] == [2]
+[1 +1]  == [1 1]
+```
+
+Being convenient means that sometimes the difference between what is acceptable
+and what is not acceptable lives in the semantics, so we can't know. In such
+cases I just accept semantically wrong but syntax correct things and group them
+in the same token (first example). I do the same when the overhead of
+generating a specific token would not really pay off (second example).
+
+- Function calls and Matrix Indexing are the same in MATLAB: `A(1)` can be any
+of them and you cannot tell them apart unless you know for sure what `A` is
+referring to. So for convenience I just generate a `function_call` for them and
+also for cell indexing `A{1}`. The "problem" with that is that this is a valid
+indexing but an invalid function call: `A(:)`. However I don't distinguish at
+all and say that all of them are `function_call`.
+
+- Function definitions, when inside a class, accepts a special syntax for the
+name of the function, allowing it to be preceded by either `get.` or `set.`,
+like `function get.name()`. I could have a `method_definition` that would allow
+that to only be valid in the class context, but I doubt that would be worth it.
+So any function anywhere can have those and be recognize as correct still.
+Given the existence of external method definition, maybe that is even the
+correct thing to do, since we don't know if the current file is inside a
+special class folder.
+
+# Installation
+
+This parser is now the default for the following editors:
+
+- Emacs: Through the `tree-sitter-langs` package.
+- Helix: Builtin.
+- Neovim: Through the `nvim-treesitter` plugin.
+
+# Screenshots
+
+![First Screenshot](https://raw.githubusercontent.com/acristoffers/tree-sitter-matlab/screenshots/s1.png)
+![Second Screenshot](https://raw.githubusercontent.com/acristoffers/tree-sitter-matlab/screenshots/s2.png)
+![Third Screenshot](https://raw.githubusercontent.com/acristoffers/tree-sitter-matlab/screenshots/s3.png)

tree_sitter_matlab-1.2.9.dist-info/RECORD

@@ -0,0 +1,27 @@
+tree_sitter_matlab/__init__.pyi,sha256=oixFm8lXsZZWYa5cRwj6brbqh37_fzN2rLE-dmX9_rA,247
+tree_sitter_matlab/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tree_sitter_matlab/binding.c,sha256=h7C-KitZXMRPV6F3j-sxahaR2CR13QC3gEPBgeilgYM,836
+tree_sitter_matlab/__init__.py,sha256=0PhvKgPyLWVNdFtOjTEoI2ptCtyqc0zgyNbglBrOc5g,1150
+tree_sitter_matlab/_binding.abi3.so,sha256=dm4SgJ1UUhtkWT5DwB3zUOXXiQgr2jb0QIRi5VyKGTY,491020
+tree_sitter_matlab/queries/helix/locals.scm,sha256=RQUp2CnxfboPN3aFs6z2ByjbbW7sunm1d5EyrfkvXOk,822
+tree_sitter_matlab/queries/helix/textobjects.scm,sha256=X2Ui1mR2cTCIL_ggmR--dTlZ4YmXlCsqMQ2sFrVW_JA,382
+tree_sitter_matlab/queries/helix/context.scm,sha256=u8d7mwEzpKe5F21VVlU8ixc6Cj5M4UD552yz2nnObBw,596
+tree_sitter_matlab/queries/helix/indents.scm,sha256=0y3gPs3b3d7_94VfVx21OIHmhxEy2KghT_byxvcmgo4,358
+tree_sitter_matlab/queries/helix/injections.scm,sha256=jbjrojqBCasUkBymLivLJ-LDjZbL4DYsAtxvcf2v0o8,69
+tree_sitter_matlab/queries/helix/folds.scm,sha256=wWsPmOq2fAEiNs0A_LEcZ4mnAQE6r7nphrpMYsi5IyU,189
+tree_sitter_matlab/queries/helix/highlights.scm,sha256=Qd95JbujY3nZLQc-IxxToWkK-i_oGfBeLLCBnlT86Ac,2481
+tree_sitter_matlab/queries/emacs/textobjects.scm,sha256=LCwIbkbUaS8g3qBxc7i4iJ5gscFauvHsUwaCCq72-Uw,3163
+tree_sitter_matlab/queries/emacs/highlights.scm,sha256=BeKmlDaygOmMcm_E52_VqorpvxptcC581KuplNmKQCY,2731
+tree_sitter_matlab/queries/neovim/locals.scm,sha256=xO9m6s3z5mvnwLZYPxurjWwLwJ3CHVgqZYtYBucvsN8,573
+tree_sitter_matlab/queries/neovim/textobjects.scm,sha256=FYlyhYV_J_bL8qcw6xKmPmysntiz9s1PaQfv2V6Etqg,3481
+tree_sitter_matlab/queries/neovim/context.scm,sha256=u8d7mwEzpKe5F21VVlU8ixc6Cj5M4UD552yz2nnObBw,596
+tree_sitter_matlab/queries/neovim/indents.scm,sha256=TareEDGJalzhO0lIfclKg1pbm9LXf-wdMdjLWQxFG4A,670
+tree_sitter_matlab/queries/neovim/injections.scm,sha256=P0dRDJFJ6ojtdDFh18Xv6zETOmBes7MAbZCtttY_NBE,19
+tree_sitter_matlab/queries/neovim/folds.scm,sha256=wWsPmOq2fAEiNs0A_LEcZ4mnAQE6r7nphrpMYsi5IyU,189
+tree_sitter_matlab/queries/neovim/highlights.scm,sha256=lSboTeNvTuG7l97cw8SQjuz61xK8dz1PlrdwhzRjjlo,2376
+tree_sitter_matlab/queries/neovim/tags.scm,sha256=EY0XStKMjGPxXbKCM3jKVH0Qvgus0CENhHQDTT3FkWk,245
+tree_sitter_matlab-1.2.9.dist-info/WHEEL,sha256=R2Q6x55j9mRwUMDKGxYbnhu7hJAJEGVdNpFAt1xB6Js,109
+tree_sitter_matlab-1.2.9.dist-info/top_level.txt,sha256=Dg13NJZGhzKz2Riy0HL6h4_yxGrw2Mq20p2lv1Q_bIE,28
+tree_sitter_matlab-1.2.9.dist-info/METADATA,sha256=_HEZZYLSkc2ZNLPxE80R7WDvE18ofLBQ7w75OhLxH5A,3843
+tree_sitter_matlab-1.2.9.dist-info/RECORD,,
+tree_sitter_matlab-1.2.9.dist-info/licenses/LICENSE,sha256=hnP1rNWb-zvRKXYKV_cgktXjwB4Fg3Uy6slJfPgAakY,1061

tree_sitter_matlab-1.2.9.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp310-abi3-musllinux_1_2_i686
+

tree_sitter_matlab-1.2.9.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2023 Álan Crístoffer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tree_sitter_matlab-1.2.9.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+_binding
+tree_sitter_matlab