tree-sitter-wasm 1.0.0

package/out/python/injections.scm

@@ -0,0 +1,30 @@
+(call
+  function: (attribute
+    object: (identifier) @_re)
+  arguments: (argument_list
+    (string
+      (string_content) @injection.content))
+  (#eq? @_re "re")
+  (#set! injection.language "regex"))
+
+(call
+  function: (attribute
+    object: (identifier) @_re)
+  arguments: (argument_list
+    (concatenated_string
+      [
+        (string
+          (string_content) @injection.content)
+        (comment)
+      ]+))
+  (#eq? @_re "re")
+  (#set! injection.language "regex"))
+
+((binary_operator
+  left: (string
+    (string_content) @injection.content)
+  operator: "%")
+  (#set! injection.language "printf"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))

package/out/python/locals.scm

@@ -0,0 +1,124 @@
+; Program structure
+(module) @local.scope
+
+(class_definition
+  body: (block
+    (expression_statement
+      (assignment
+        left: (identifier) @local.definition.field)))) @local.scope
+
+(class_definition
+  body: (block
+    (expression_statement
+      (assignment
+        left: (_
+          (identifier) @local.definition.field))))) @local.scope
+
+; Imports
+(aliased_import
+  alias: (identifier) @local.definition.import) @local.scope
+
+(import_statement
+  name: (dotted_name
+    (identifier) @local.definition.import)) @local.scope
+
+(import_from_statement
+  name: (dotted_name
+    (identifier) @local.definition.import)) @local.scope
+
+; Function with parameters, defines parameters
+(parameters
+  (identifier) @local.definition.parameter)
+
+(default_parameter
+  (identifier) @local.definition.parameter)
+
+(typed_parameter
+  (identifier) @local.definition.parameter)
+
+(typed_default_parameter
+  (identifier) @local.definition.parameter)
+
+; *args parameter
+(parameters
+  (list_splat_pattern
+    (identifier) @local.definition.parameter))
+
+; **kwargs parameter
+(parameters
+  (dictionary_splat_pattern
+    (identifier) @local.definition.parameter))
+
+; Function defines function and scope
+((function_definition
+  name: (identifier) @local.definition.function) @local.scope
+  (#set! definition.function.scope "parent"))
+
+((class_definition
+  name: (identifier) @local.definition.type) @local.scope
+  (#set! definition.type.scope "parent"))
+
+(class_definition
+  body: (block
+    (function_definition
+      name: (identifier) @local.definition.method)))
+
+; Loops
+; not a scope!
+(for_statement
+  left: (pattern_list
+    (identifier) @local.definition.var))
+
+(for_statement
+  left: (tuple_pattern
+    (identifier) @local.definition.var))
+
+(for_statement
+  left: (identifier) @local.definition.var)
+
+; not a scope!
+;(while_statement) @local.scope
+; for in list comprehension
+(for_in_clause
+  left: (identifier) @local.definition.var)
+
+(for_in_clause
+  left: (tuple_pattern
+    (identifier) @local.definition.var))
+
+(for_in_clause
+  left: (pattern_list
+    (identifier) @local.definition.var))
+
+(dictionary_comprehension) @local.scope
+
+(list_comprehension) @local.scope
+
+(set_comprehension) @local.scope
+
+; Assignments
+(assignment
+  left: (identifier) @local.definition.var)
+
+(assignment
+  left: (pattern_list
+    (identifier) @local.definition.var))
+
+(assignment
+  left: (tuple_pattern
+    (identifier) @local.definition.var))
+
+(assignment
+  left: (attribute
+    (identifier)
+    (identifier) @local.definition.field))
+
+; Walrus operator  x := 1
+(named_expression
+  (identifier) @local.definition.var)
+
+(as_pattern
+  alias: (as_pattern_target) @local.definition.var)
+
+; REFERENCES
+(identifier) @local.reference

package/out/python/tags.scm

@@ -0,0 +1,14 @@
+(module (expression_statement (assignment left: (identifier) @name) @definition.constant))
+
+(class_definition
+  name: (identifier) @name) @definition.class
+
+(function_definition
+  name: (identifier) @name) @definition.function
+
+(call
+  function: [
+      (identifier) @name
+      (attribute
+        attribute: (identifier) @name)
+  ]) @reference.call

package/out/qmljs/folds.scm

@@ -0,0 +1,8 @@
+[
+  (ui_object_definition)
+  (function_declaration)
+  (statement_block)
+  (if_statement)
+  (ui_binding)
+  (comment)
+] @fold

package/out/qmljs/highlights.scm

@@ -0,0 +1,61 @@
+;;; Annotations
+
+(ui_annotation
+  "@" @operator
+  type_name: [
+    (identifier) @attribute
+    (nested_identifier (identifier) @attribute)
+  ])
+
+;;; Properties
+
+(ui_object_definition_binding
+  name: [
+    (identifier) @property
+    (nested_identifier (identifier) @property)
+  ])
+
+(ui_binding
+  name: [
+    (identifier) @property
+    (nested_identifier (identifier) @property)
+  ])
+
+;; locals query appears not working unless id: <ref> isn't a parameter.
+(ui_binding
+  name: (identifier) @property
+  (#eq? @property "id")
+  value: (expression_statement (identifier) @variable.parameter))
+
+(ui_property
+  name: (identifier) @property)
+
+(ui_required
+  name: (identifier) @property)
+
+(ui_list_property_type
+  ["<" ">"] @punctuation.bracket)
+
+;;; Signals
+
+(ui_signal
+  name: (identifier) @function.signal)
+
+(ui_signal_parameter
+  (identifier) @variable.parameter)
+
+;;; Keywords
+
+[
+  "as"
+  "component"
+  "default"
+  "final"
+  "import"
+  "on"
+  "pragma"
+  "property"
+  "readonly"
+  "required"
+  "signal"
+] @keyword

package/out/qmljs/injections.scm

@@ -0,0 +1 @@
+; inherits: ecma

package/out/qmljs/locals.scm

@@ -0,0 +1,6 @@
+;;; Definitions
+
+(ui_binding
+  name: (identifier) @property
+  (#eq? @property "id")
+  value: (expression_statement (identifier) @local.definition))

package/out/query/folds.scm

@@ -0,0 +1,6 @@
+[
+  (named_node)
+  (predicate)
+  (grouping)
+  (list)
+] @fold

package/out/query/highlights.scm

@@ -0,0 +1,102 @@
+(string) @string
+
+(escape_sequence) @string.escape
+
+(capture
+  (identifier) @type)
+
+(predicate
+  name: (identifier) @function.call)
+
+(named_node
+  name: (identifier) @variable)
+
+(missing_node
+  name: (identifier) @variable)
+
+(field_definition
+  name: (identifier) @variable.member)
+
+(negated_field
+  "!" @operator
+  (identifier) @property)
+
+(comment) @comment @spell
+
+(quantifier) @operator
+
+(predicate_type) @punctuation.special
+
+"." @operator
+
+[
+  "["
+  "]"
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  ":"
+  "/"
+] @punctuation.delimiter
+
+[
+  "@"
+  "#"
+] @punctuation.special
+
+(predicate
+  "." @punctuation.special)
+
+"_" @character.special
+
+"MISSING" @keyword
+
+((parameters
+  (identifier) @number)
+  (#match? @number "^[-+]?[0-9]+(.[0-9]+)?$"))
+
+((program
+  .
+  (comment)*
+  .
+  (comment) @keyword.import @nospell)
+  (#lua-match? @keyword.import "^;+ *inherits *:"))
+
+((program
+  .
+  (comment)*
+  .
+  (comment) @keyword.directive @nospell)
+  (#lua-match? @keyword.directive "^;+ *extends *$"))
+
+((comment) @keyword.directive @nospell
+  (#lua-match? @keyword.directive "^;+%s*format%-ignore%s*$"))
+
+((predicate
+  name: (identifier) @_name
+  parameters: (parameters
+    .
+    (capture)?
+    .
+    (identifier) @property))
+  (#eq? @_name "set"))
+
+((predicate
+  name: (identifier) @_name
+  parameters: (parameters
+    (string
+      "\"" @string
+      "\"" @string) @string.regexp))
+  (#any-of? @_name "match" "not-match" "vim-match" "not-vim-match" "lua-match" "not-lua-match"))
+
+((predicate
+  name: (identifier) @_name
+  parameters: (parameters
+    (string
+      "\"" @string
+      "\"" @string) @string.regexp
+    .
+    (string) .))
+  (#any-of? @_name "gsub" "not-gsub"))

package/out/query/indents.scm

@@ -0,0 +1,25 @@
+[
+  (list)
+  (named_node)
+  (grouping)
+  (predicate)
+  "["
+] @indent.begin
+
+; ERROR node indents
+(ERROR
+  "(") @indent.begin
+
+"]" @indent.branch @indent.end
+
+[
+  ")"
+  "?"
+  "*"
+  "+"
+] @indent.end
+
+; Captures always mark the end of a node
+; Because of that, mark it as indent.end
+(capture
+  name: (identifier) @indent.end)

package/out/query/injections.scm

@@ -0,0 +1,28 @@
+((predicate
+  name: (identifier) @_name
+  parameters: (parameters
+    (string
+      (string_content) @injection.content)))
+  (#any-of? @_name "match" "not-match" "any-match" "vim-match" "not-vim-match" "any-vim-match")
+  (#set! injection.language "regex"))
+
+((predicate
+  name: (identifier) @_name
+  parameters: (parameters
+    (string
+      (string_content) @injection.content)))
+  (#any-of? @_name "lua-match" "not-lua-match" "any-lua-match")
+  (#set! injection.language "luap"))
+
+((predicate
+  name: (identifier) @_name
+  parameters: (parameters
+    (string
+      (string_content) @injection.content)
+    .
+    (string) .))
+  (#any-of? @_name "gsub" "not-gsub")
+  (#set! injection.language "luap"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))

package/out/query/locals.scm

@@ -0,0 +1,21 @@
+(program) @local.scope
+
+(program
+  (named_node) @local.scope)
+
+(program
+  (anonymous_node) @local.scope)
+
+(program
+  (grouping) @local.scope)
+
+(identifier) @local.reference
+
+(named_node
+  (capture) @local.definition.var)
+
+(anonymous_node
+  (capture) @local.definition.var)
+
+(grouping
+  (capture) @local.definition.var)

package/out/r/highlights.scm

@@ -0,0 +1,112 @@
+; highlights.scm
+
+; Literals
+
+(integer) @number
+(float) @number
+(complex) @number
+
+(string) @string
+(string (string_content (escape_sequence) @string.escape))
+
+; Comments
+
+(comment) @comment
+
+; Operators
+
+[
+  "?" ":=" "=" "<-" "<<-" "->" "->>"
+  "~" "|>" "||" "|" "&&" "&"
+  "<" "<=" ">" ">=" "==" "!="
+  "+" "-" "*" "/" "::" ":::"
+  "**" "^" "$" "@" ":"
+  "special"
+] @operator
+
+; Punctuation
+
+[
+  "("  ")"
+  "{"  "}"
+  "["  "]"
+  "[[" "]]"
+] @punctuation.bracket
+
+(comma) @punctuation.delimiter
+
+; Variables
+
+(identifier) @variable
+
+; Functions
+
+(binary_operator
+    lhs: (identifier) @function
+    operator: "<-"
+    rhs: (function_definition)
+)
+
+(binary_operator
+    lhs: (identifier) @function
+    operator: "="
+    rhs: (function_definition)
+)
+
+; Calls
+
+(call function: (identifier) @function)
+
+; Parameters
+
+(parameters (parameter name: (identifier) @variable.parameter))
+(arguments (argument name: (identifier) @variable.parameter))
+
+; Namespace
+
+(namespace_operator lhs: (identifier) @namespace)
+
+(call
+    function: (namespace_operator rhs: (identifier) @function)
+)
+
+; Keywords
+
+(function_definition name: "function" @keyword.function)
+(function_definition name: "\\" @operator)
+
+[
+  "in"
+  (return)
+  (next)
+  (break)
+] @keyword
+
+[
+  "if"
+  "else"
+] @conditional
+
+[
+  "while"
+  "repeat"
+  "for"
+] @repeat
+
+[
+  (true)
+  (false)
+] @boolean
+
+[
+  (null)
+  (inf)
+  (nan)
+  (na)
+  (dots)
+  (dot_dot_i)
+] @constant.builtin
+
+; Error
+
+(ERROR) @error

package/out/r/indents.scm

@@ -0,0 +1,33 @@
+[
+  (braced_expression)
+  (parenthesized_expression)
+  (call)
+  "if"
+  "else"
+  "while"
+  "repeat"
+  "for"
+] @indent.begin
+
+(binary_operator
+  rhs: (_) @_no_indent
+  (#not-kind-eq? @_no_indent function_definition)) @indent.begin
+
+[
+  "}"
+  ")"
+] @indent.branch
+
+((parameters
+  .
+  (parameter
+    name: (identifier))) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+[
+  ")"
+  "}"
+] @indent.end
+
+(comment) @indent.ignore

package/out/r/injections.scm

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

package/out/r/locals.scm

@@ -0,0 +1,18 @@
+; locals.scm
+
+(function_definition) @local.scope
+
+(argument  name: (identifier) @local.definition)
+(parameter name: (identifier) @local.definition)
+
+(binary_operator
+    lhs: (identifier) @local.definition
+    operator: "<-")
+(binary_operator
+    lhs: (identifier) @local.definition
+    operator: "=")
+(binary_operator
+    operator: "->"
+    rhs: (identifier) @local.definition)
+
+(identifier) @local.reference

package/out/r/tags.scm

@@ -0,0 +1,21 @@
+(binary_operator
+    lhs: (identifier) @name
+    operator: "<-"
+    rhs: (function_definition)
+) @definition.function
+
+(binary_operator
+    lhs: (identifier) @name
+    operator: "="
+    rhs: (function_definition)
+) @definition.function
+
+(call
+    function: (identifier) @name
+) @reference.call
+
+(call
+    function: (namespace_operator
+        rhs: (identifier) @name
+    )
+) @reference.call

package/out/racket/folds.scm

@@ -0,0 +1,2 @@
+(program
+  (list) @fold)