tree-sitter-wasm 1.0.0

package/out/just/injections.scm

@@ -0,0 +1,44 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+; The right side of =~ literals
+(regex_literal
+  (_) @injection.content
+  (#set! injection.language "regex"))
+
+; Default to bash highlighting for non-shebang recipes and commands
+(recipe
+  (recipe_body
+    !shebang) @injection.content
+  (#set! injection.include-children)
+  (#set! injection.language "bash"))
+
+(external_command
+  (command_body) @injection.content
+  (#set! injection.language "bash"))
+
+; For shebang recipes, use the shebang executable name as the language by default
+(recipe
+  (recipe_body
+    (shebang
+      (language) @injection.language)) @injection.content
+  (#not-any-of? @injection.language "python3" "nodejs" "node")
+  (#set! injection.include-children))
+
+; python3 -> python
+(recipe
+  (recipe_body
+    (shebang
+      (language) @_lang)) @injection.content
+  (#eq? @_lang "python3")
+  (#set! injection.language "python")
+  (#set! injection.include-children))
+
+; node/nodejs -> javascript
+(recipe
+  (recipe_body
+    (shebang
+      (language) @_lang)) @injection.content
+  (#any-of? @_lang "node" "nodejs")
+  (#set! injection.language "javascript")
+  (#set! injection.include-children))

package/out/just/locals.scm

@@ -0,0 +1,35 @@
+; Source: https://github.com/IndianBoy42/tree-sitter-just/blob/main/queries/just/locals.scm
+; Scope
+(recipe) @local.scope
+
+; Definitions
+(alias
+  left: (identifier) @local.definition.var)
+
+(assignment
+  left: (identifier) @local.definition.var)
+
+(module
+  name: (identifier) @local.definition.namespace)
+
+(parameter
+  name: (identifier) @local.definition.var)
+
+(recipe_header
+  name: (identifier) @local.definition.function)
+
+; References
+(alias
+  right: (identifier) @local.reference)
+
+(function_call
+  name: (identifier) @local.reference)
+
+(dependency
+  name: (identifier) @local.reference)
+
+(dependency_expression
+  name: (identifier) @local.reference)
+
+(value
+  (identifier) @local.reference)

package/out/kdl/folds.scm

@@ -0,0 +1,8 @@
+; Folds
+
+[
+  (node)
+  (node_children)
+  (string)
+  (multi_line_comment)
+] @fold

package/out/kdl/highlights.scm

@@ -0,0 +1,58 @@
+; Types
+
+(node (identifier) @type)
+
+(type) @type
+
+(annotation_type) @type.builtin
+
+; Properties
+
+(prop (identifier) @property)
+
+; Variables
+
+(identifier) @variable
+
+; Operators
+[
+ "="
+ "+"
+ "-"
+] @operator
+
+; Literals
+
+(string) @string
+
+(escape) @string.escape
+
+(number) @number
+
+(number (decimal) @float)
+(number (exponent) @float)
+
+(boolean) @boolean
+
+"null" @constant.builtin
+
+; Punctuation
+
+["{" "}"] @punctuation.bracket
+
+["(" ")"] @punctuation.bracket
+
+[
+  ";"
+] @punctuation.delimiter
+
+; Comments
+
+[
+  (single_line_comment)
+  (multi_line_comment)
+] @comment @spell
+
+(node (node_comment) (#set! "priority" 105)) @comment
+(node (node_field (node_field_comment) (#set! "priority" 105)) @comment)
+(node_children (node_children_comment) (#set! "priority" 105)) @comment

package/out/kdl/indents.scm

@@ -0,0 +1,7 @@
+(node (node_children) @indent)
+
+"}" @indent_end
+
+[ "{" "}" ] @branch
+
+[ "(" ")" ] @branch

package/out/kdl/injections.scm

@@ -0,0 +1,4 @@
+[
+  (single_line_comment)
+  (multi_line_comment)
+] @comment

package/out/kdl/locals.scm

@@ -0,0 +1,10 @@
+(document) @scope
+(node (node_children) @scope)
+(node_children (node) @scope)
+
+(identifier) @reference
+
+(node_field) @definition.field
+
+(node (identifier) @definition.type)
+(type) @definition.type

package/out/kotlin/folds.scm

@@ -0,0 +1,13 @@
+[
+  (import_list)
+  (when_expression)
+  (control_structure_body)
+  (lambda_literal)
+  (function_body)
+  (primary_constructor)
+  (secondary_constructor)
+  (anonymous_initializer)
+  (class_body)
+  (enum_class_body)
+  (interpolated_expression)
+] @fold

package/out/kotlin/highlights.scm

@@ -0,0 +1,380 @@
+;; Based on the nvim-treesitter highlighting, which is under the Apache license.
+;; See https://github.com/nvim-treesitter/nvim-treesitter/blob/f8ab59861eed4a1c168505e3433462ed800f2bae/queries/kotlin/highlights.scm
+;;
+;; The only difference in this file is that queries using #lua-match?
+;; have been removed.
+
+;;; Identifiers
+
+(simple_identifier) @variable
+
+; `it` keyword inside lambdas
+; FIXME: This will highlight the keyword outside of lambdas since tree-sitter
+;        does not allow us to check for arbitrary nestation
+((simple_identifier) @variable.builtin
+(#eq? @variable.builtin "it"))
+
+; `field` keyword inside property getter/setter
+; FIXME: This will highlight the keyword outside of getters and setters
+;        since tree-sitter does not allow us to check for arbitrary nestation
+((simple_identifier) @variable.builtin
+(#eq? @variable.builtin "field"))
+
+; `this` this keyword inside classes
+(this_expression) @variable.builtin
+
+; `super` keyword inside classes
+(super_expression) @variable.builtin
+
+(class_parameter
+	(simple_identifier) @property)
+
+(class_body
+	(property_declaration
+		(variable_declaration
+			(simple_identifier) @property)))
+
+; id_1.id_2.id_3: `id_2` and `id_3` are assumed as object properties
+(_
+	(navigation_suffix
+		(simple_identifier) @property))
+
+(enum_entry
+	(simple_identifier) @constant)
+
+(type_identifier) @type
+
+((type_identifier) @type.builtin
+	(#any-of? @type.builtin
+		"Byte"
+		"Short"
+		"Int"
+		"Long"
+		"UByte"
+		"UShort"
+		"UInt"
+		"ULong"
+		"Float"
+		"Double"
+		"Boolean"
+		"Char"
+		"String"
+		"Array"
+		"ByteArray"
+		"ShortArray"
+		"IntArray"
+		"LongArray"
+		"UByteArray"
+		"UShortArray"
+		"UIntArray"
+		"ULongArray"
+		"FloatArray"
+		"DoubleArray"
+		"BooleanArray"
+		"CharArray"
+		"Map"
+		"Set"
+		"List"
+		"EmptyMap"
+		"EmptySet"
+		"EmptyList"
+		"MutableMap"
+		"MutableSet"
+		"MutableList"
+))
+
+(package_header
+	. (identifier)) @namespace
+
+(import_header
+	"import" @include)
+
+
+; TODO: Seperate labeled returns/breaks/continue/super/this
+;       Must be implemented in the parser first
+(label) @label
+
+;;; Function definitions
+
+(function_declaration
+	. (simple_identifier) @function)
+
+(getter
+	("get") @function.builtin)
+(setter
+	("set") @function.builtin)
+
+(primary_constructor) @constructor
+(secondary_constructor
+	("constructor") @constructor)
+
+(constructor_invocation
+	(user_type
+		(type_identifier) @constructor))
+
+(anonymous_initializer
+	("init") @constructor)
+
+(parameter
+	(simple_identifier) @parameter)
+
+(parameter_with_optional_type
+	(simple_identifier) @parameter)
+
+; lambda parameters
+(lambda_literal
+	(lambda_parameters
+		(variable_declaration
+			(simple_identifier) @parameter)))
+
+;;; Function calls
+
+; function()
+(call_expression
+	. (simple_identifier) @function)
+
+; object.function() or object.property.function()
+(call_expression
+	(navigation_expression
+		(navigation_suffix
+			(simple_identifier) @function) . ))
+
+(call_expression
+	. (simple_identifier) @function.builtin
+    (#any-of? @function.builtin
+		"arrayOf"
+		"arrayOfNulls"
+		"byteArrayOf"
+		"shortArrayOf"
+		"intArrayOf"
+		"longArrayOf"
+		"ubyteArrayOf"
+		"ushortArrayOf"
+		"uintArrayOf"
+		"ulongArrayOf"
+		"floatArrayOf"
+		"doubleArrayOf"
+		"booleanArrayOf"
+		"charArrayOf"
+		"emptyArray"
+		"mapOf"
+		"setOf"
+		"listOf"
+		"emptyMap"
+		"emptySet"
+		"emptyList"
+		"mutableMapOf"
+		"mutableSetOf"
+		"mutableListOf"
+		"print"
+		"println"
+		"error"
+		"TODO"
+		"run"
+		"runCatching"
+		"repeat"
+		"lazy"
+		"lazyOf"
+		"enumValues"
+		"enumValueOf"
+		"assert"
+		"check"
+		"checkNotNull"
+		"require"
+		"requireNotNull"
+		"with"
+		"suspend"
+		"synchronized"
+))
+
+;;; Literals
+
+[
+	(line_comment)
+	(multiline_comment)
+	(shebang_line)
+] @comment
+
+(real_literal) @float
+[
+	(integer_literal)
+	(long_literal)
+	(hex_literal)
+	(bin_literal)
+	(unsigned_literal)
+] @number
+
+[
+	"null" ; should be highlighted the same as booleans
+	(boolean_literal)
+] @boolean
+
+(character_literal) @character
+
+(string_literal) @string
+
+(character_escape_seq) @string.escape
+
+; There are 3 ways to define a regex
+;    - "[abc]?".toRegex()
+(call_expression
+	(navigation_expression
+		((string_literal) @string.regex)
+		(navigation_suffix
+			((simple_identifier) @_function
+			(#eq? @_function "toRegex")))))
+
+;    - Regex("[abc]?")
+(call_expression
+	((simple_identifier) @_function
+	(#eq? @_function "Regex"))
+	(call_suffix
+		(value_arguments
+			(value_argument
+				(string_literal) @string.regex))))
+
+;   - Regex.fromLiteral("[abc]?")
+(call_expression
+	(navigation_expression
+		((simple_identifier) @_class
+		(#eq? @_class "Regex"))
+		(navigation_suffix
+			((simple_identifier) @_function
+			(#eq? @_function "fromLiteral"))))
+	(call_suffix
+		(value_arguments
+			(value_argument
+				(string_literal) @string.regex))))
+
+;;; Keywords
+
+(type_alias "typealias" @keyword)
+[
+	(class_modifier)
+	(member_modifier)
+	(function_modifier)
+	(property_modifier)
+	(platform_modifier)
+	(variance_modifier)
+	(parameter_modifier)
+	(visibility_modifier)
+	(reification_modifier)
+	(inheritance_modifier)
+]@keyword
+
+[
+	"val"
+	"var"
+	"enum"
+	"class"
+	"object"
+	"interface"
+;	"typeof" ; NOTE: It is reserved for future use
+] @keyword
+
+("fun") @keyword.function
+
+(jump_expression) @keyword.return
+
+[
+	"if"
+	"else"
+	"when"
+] @conditional
+
+[
+	"for"
+	"do"
+	"while"
+] @repeat
+
+[
+	"try"
+	"catch"
+	"throw"
+	"finally"
+] @exception
+
+
+(annotation
+	"@" @attribute (use_site_target)? @attribute)
+(annotation
+	(user_type
+		(type_identifier) @attribute))
+(annotation
+	(constructor_invocation
+		(user_type
+			(type_identifier) @attribute)))
+
+(file_annotation
+	"@" @attribute "file" @attribute ":" @attribute)
+(file_annotation
+	(user_type
+		(type_identifier) @attribute))
+(file_annotation
+	(constructor_invocation
+		(user_type
+			(type_identifier) @attribute)))
+
+;;; Operators & Punctuation
+
+[
+	"!"
+	"!="
+	"!=="
+	"="
+	"=="
+	"==="
+	">"
+	">="
+	"<"
+	"<="
+	"||"
+	"&&"
+	"+"
+	"++"
+	"+="
+	"-"
+	"--"
+	"-="
+	"*"
+	"*="
+	"/"
+	"/="
+	"%"
+	"%="
+	"?."
+	"?:"
+	"!!"
+	"is"
+	"!is"
+	"in"
+	"!in"
+	"as"
+	"as?"
+	".."
+	"->"
+] @operator
+
+[
+	"(" ")"
+	"[" "]"
+	"{" "}"
+] @punctuation.bracket
+
+[
+	"."
+	","
+	";"
+	":"
+	"::"
+] @punctuation.delimiter
+
+; NOTE: `interpolated_identifier`s can be highlighted in any way
+(string_literal
+	"$" @punctuation.special
+	(interpolated_identifier) @none)
+(string_literal
+	"${" @punctuation.special
+	(interpolated_expression) @none
+	"}" @punctuation.special)

package/out/kotlin/injections.scm

@@ -0,0 +1,52 @@
+([
+  (line_comment)
+  (multiline_comment)
+] @injection.content
+  (#set! injection.language "comment"))
+
+; There are 3 ways to define a regex
+;    - "[abc]?".toRegex()
+(call_expression
+  (navigation_expression
+    ((string_literal
+      (string_content) @injection.content)
+      (#set! injection.language "regex"))
+    (navigation_suffix
+      ((simple_identifier) @_function
+        (#eq? @_function "toRegex")))))
+
+;    - Regex("[abc]?")
+(call_expression
+  ((simple_identifier) @_function
+    (#eq? @_function "Regex"))
+  (call_suffix
+    (value_arguments
+      (value_argument
+        (string_literal
+          (string_content) @injection.content)
+        (#set! injection.language "regex")))))
+
+;    - Regex.fromLiteral("[abc]?")
+(call_expression
+  (navigation_expression
+    ((simple_identifier) @_class
+      (#eq? @_class "Regex"))
+    (navigation_suffix
+      ((simple_identifier) @_function
+        (#eq? @_function "fromLiteral"))))
+  (call_suffix
+    (value_arguments
+      (value_argument
+        (string_literal
+          (string_content) @injection.content)
+        (#set! injection.language "regex")))))
+
+; "pi = %.2f".format(3.14159)
+((call_expression
+  (navigation_expression
+    (string_literal
+      (string_content) @injection.content)
+    (navigation_suffix
+      (simple_identifier) @_method)))
+  (#eq? @_method "format")
+  (#set! injection.language "printf"))

package/out/kotlin/locals.scm

@@ -0,0 +1,78 @@
+; Imports
+(package_header
+  .
+  (identifier) @local.definition.namespace)
+
+(import_header
+  (identifier
+    (simple_identifier) @local.definition.import .)
+  (import_alias
+    (type_identifier) @local.definition.import)?)
+
+; Functions
+(function_declaration
+  .
+  (simple_identifier) @local.definition.function
+  (#set! definition.function.scope "parent"))
+
+(class_body
+  (function_declaration
+    .
+    (simple_identifier) @local.definition.method)
+  (#set! definition.method.scope "parent"))
+
+; Variables
+(function_declaration
+  (function_value_parameters
+    (parameter
+      (simple_identifier) @local.definition.parameter)))
+
+(lambda_literal
+  (lambda_parameters
+    (variable_declaration
+      (simple_identifier) @local.definition.parameter)))
+
+; NOTE: temporary fix for treesitter bug that causes delay in file opening
+;(class_body
+;  (property_declaration
+;    (variable_declaration
+;      (simple_identifier) @local.definition.field)))
+(class_declaration
+  (primary_constructor
+    (class_parameter
+      (simple_identifier) @local.definition.field)))
+
+(enum_class_body
+  (enum_entry
+    (simple_identifier) @local.definition.field))
+
+(variable_declaration
+  (simple_identifier) @local.definition.var)
+
+; Types
+(class_declaration
+  (type_identifier) @local.definition.type
+  (#set! definition.type.scope "parent"))
+
+(type_alias
+  (type_identifier) @local.definition.type
+  (#set! definition.type.scope "parent"))
+
+; Scopes
+[
+  (if_expression)
+  (when_expression)
+  (when_entry)
+  (for_statement)
+  (while_statement)
+  (do_while_statement)
+  (lambda_literal)
+  (function_declaration)
+  (primary_constructor)
+  (secondary_constructor)
+  (anonymous_initializer)
+  (class_declaration)
+  (enum_class_body)
+  (enum_entry)
+  (interpolated_expression)
+] @local.scope