tree-sitter-wasm 1.0.0

package/out/d/nova-highlights.scm

@@ -0,0 +1,283 @@
+;
+; These are the highlight queries used by the
+; Nova editor (as of version 10).
+;
+; all forms of comment
+(comment) @comment
+
+; line directive
+(directive) @processing
+(shebang) @processing
+
+(null) @value.null
+[
+(true)
+(false)
+] @value.boolean
+
+[
+(this)
+(super)
+] @keyword.self
+
+(int_literal) @value.number
+(float_literal) @value.number
+(char_literal) @value.number ; not sure what is best for this
+(special_keyword) @value.symbols
+(htmlentity) @value.entity
+(escape_sequence) @value.entity
+
+[
+	"("
+	")"
+	"["
+	"]"
+	"{"
+	"}"
+] @bracket
+
+[
+	(not_in)
+	(not_is)
+] @keyword.operator
+
+[
+	(lazy)
+	(align)
+	(extern)
+	(static)
+	(abstract)
+	(final)
+	(override)
+	(synchronized)
+	(auto)
+	(scope)
+	(gshared)
+	(ref)
+	(deprecated)
+	(nothrow)
+	(pure)
+	(type_ctor)
+] @keyword.modifier
+
+; these are special only when it shows up here
+(parameter_attribute (return) @keyword.modifier)
+(parameter_attribute (in) @keyword.modifier)
+(parameter_attribute (out) @keyword.modifier)
+
+(function_declaration (identifier) @identifier.function)
+(call_expression (type (identifier) @identifier.function))
+(template_instance (identifier) @identifier.method)
+
+[
+	"/="
+	"/"
+	".."
+	"..."
+	"&"
+	"&="
+	"&&"
+	"|"
+	"|="
+	"||"
+	"-"
+	"-="
+	"--"
+	"+"
+	"+="
+	"++"
+	"<"
+	"<="
+	"<<"
+	"<<="
+	">"
+	">="
+	">>="
+	">>>="
+	">>"
+	">>>"
+	"!"
+	"!="
+	"?"
+	"$"
+	"="
+	"=="
+	"*"
+	"*="
+	"%"
+	"%="
+	"^"
+	"^="
+	"^^"
+	"^^="
+	"~"
+	"~="
+	"@"
+	"=>"
+] @operator
+
+[
+	(break)
+	(case)
+	(catch)
+	(continue)
+	(do)
+	(default)
+	(finally)
+	(else)
+	(goto)
+	(if)
+	(switch)
+	(try)
+] @keyword.control
+
+; builtin types.  it would be nice to have a different markup for it.
+[
+	(void)
+	(bool)
+	(byte)
+	(ubyte)
+	(char)
+	(short)
+	(ushort)
+	(wchar)
+	(dchar)
+	(int)
+	(uint)
+	(long)
+	(ulong)
+	(real)
+	(double)
+	(float)
+	(size_t)
+	(ptrdiff_t)
+	(string)
+	(cstring)
+	(dstring)
+	(wstring)
+	(noreturn)
+] @identifier.type.core
+
+[
+	(class)
+	(struct)
+	(interface)
+	(union)
+	(enum)
+	(function)
+	(delegate)
+] @keyword.construct
+
+; some editors (Helix) have a different selector for return statements.
+; TODO: this keyword is sometimes a parameter attribute
+(return) @keyword.control
+
+; some editors (Helix) have a selector for imports
+(import) @keyword.control
+
+; some editors have a repeat keyword construct
+[
+	(for)
+	(foreach)
+	(foreach_reverse)
+	(while)
+] @keyword.control
+
+(cast) @keyword.operator
+
+[
+	(abstract)
+	(alias)
+	(align)
+	(asm)
+	(assert)
+	(auto)
+	(cast)
+	(debug)
+	(delete)
+	(deprecated)
+	(export)
+	(extern)
+	(final)
+	(invariant)
+	(is)
+	; "macro" - obsolete
+	(mixin)
+	(module)
+	(new)
+	(override)
+	(pragma)
+	(scope)
+	(synchronized)
+	(template)
+	(throw)
+	(typeid)
+	(typeof)
+	(unittest)
+	(version)
+	(with)
+	(traits)
+	(vector)
+	(parameters_)
+] @keyword
+
+[
+	(this)
+	(super)
+] @keyword.self
+
+[
+	(const)
+	(immutable)
+	(in)
+	(inout)
+	(lazy)
+	(ref)
+	(protected)
+	(private)
+	(package)
+	(public)
+	(pure)
+	(gshared)
+	(shared)
+	(static)
+] @keyword.modifier
+
+[
+	(cent)
+	(ucent)
+	(ireal)
+	(idouble)
+	(ifloat)
+	(creal)
+	(cdouble)
+	(cfloat)
+] @invalid ; these types are deprecated
+
+(debug_condition (debug) (int_literal) @invalid) ; deprecated in 2.101
+(debug_specification (debug) (int_literal) @invalid) ; deprecated in 2.101
+(version_condition (version) (int_literal) @invalid) ; deprecated in 2.101
+(version_specification (version) (int_literal) @invalid) ; deprecated in 2.101
+(version_condition (identifier) @value.symbol)
+
+(module_fqn) @processing ; this is a crummy workaround since we don't have anything for imports
+(module_declaration (module_fqn)) @definition.package
+(class_declaration (identifier) @identifier.type.class)
+(struct_declaration (identifier) @identifier.type.struct)
+(interface_declaration (identifier) @identifier.type.protocol)
+(at_attribute) @identifier.property
+; conventional naming
+(type (identifier) @_type (#match? @_type "^[A-Z]")) @identifier.type.class
+(type (identifier) @_type (#not-match? @_type "^[A-Z]")) @identifier.type
+(enum_declaration (enum) . (identifier) @identifier.type.enum)
+(auto_declaration (storage_class (auto)) . (identifier) @identifier.variable)
+(manifest_declarator . (identifier) @identifier.constant)
+(identifier) @identifier ; catch all
+(declarator . (identifier) @identifier.variable)
+(declarator "=" (void) @value.null)
+
+((enum_member  . (identifier) @identifier.property) (#set! role enum-member))
+
+(interpolation_expression "$(" @bracket)
+(interpolation_expression) @string-template.value
+(string_literal) @string

package/out/d/nova-symbols.scm

@@ -0,0 +1,23 @@
+((module_def (module_declaration (module_fqn) @name)) @subtree (#set! role package))
+
+((struct_declaration (struct) . (identifier) @name) @subtree (#set! role struct))
+((enum_declaration (enum) . (identifier) @name) @subtree (#set! role enum))
+
+((class_declaration (class) . (identifier) @name) @subtree (#set! role class))
+((constructor (this) @name) @subtree (#set! role constructor))
+((destructor (this) @name) @subtree (#set! role destructor))
+((postblit (this) @name) @subtree (#set! role constructor))
+
+((manifest_declarator . (identifier) @name) @subtree (#set! role constant))
+
+((function_declaration (identifier) @name) @subtree (#set! role function-or-method))
+
+((aggregate_body (variable_declaration (declarator (identifier) @name) @subtree (#set! role property))))
+
+((union_declaration (union) . (identifier) @name) @subtree (#set! role union))
+
+((alias_declaration (alias_initializer . (identifier) @name) @subtree (#set! role type)))
+
+((anonymous_enum_declaration ((enum_member . (identifier) @name) @subtree (#set! role constant))))
+
+((enum_declaration ((enum_member . (identifier) @name) @subtree (#set! role enum-member))))

package/out/d/tags.scm

@@ -0,0 +1,28 @@
+(module_def (module_declaration (module_fqn) @name)) @definition.module
+
+(struct_declaration (struct) . (identifier) @name) @definition.class
+(interface_declaration (interface) . (identifier) @name) @definition.interface
+(enum_declaration (enum) . (identifier) @name) @definition.type
+
+(class_declaration (class) . (identifier) @name) @definition.class
+(constructor (this) @name) @definition.method
+(destructor (this) @name) @definition.method
+(postblit (this) @name) @definition.method
+
+(manifest_declarator . (identifier) @name) @definition.type
+
+(function_declaration (identifier) @name) @definition.function
+
+(union_declaration (union) . (identifier) @name) @definition.type
+
+(anonymous_enum_declaration (enum_member . (identifier) @name)) @definition.constant
+
+(enum_declaration (enum_member . (identifier) @name)) @definition.constant
+
+(call_expression (identifier) @name) @reference.call
+(call_expression (type (template_instance (identifier) @name))) @reference.call
+(parameter (type (identifier) @name) @reference.class (identifier))
+
+(variable_declaration (type (identifier) @name) @reference.class (declarator))
+
+((alias_declaration (alias_initializer . (identifier) @name))) @definition.class

package/out/d/textobjects.scm

@@ -0,0 +1,9 @@
+(function_declaration (function_body) @function.inside) @function.around
+(comment) @comment.inside
+(comment)+ @comment.around
+(class_declaration (aggregate_body) @class.inside) @class.around
+(interface_declaration (aggregate_body) @class.inside) @class.around
+(struct_declaration (aggregate_body) @class.inside) @class.around
+(unittest_declaration (block_statement) @test.inside) @test.around
+(parameter) @parameter.inside
+(template_parameter) @parameter.inside

package/out/dart/folds.scm

@@ -0,0 +1,8 @@
+[
+  (class_definition)
+	(enum_declaration)
+
+  (function_body)
+
+	(block)
+] @fold

package/out/dart/highlights.scm

@@ -0,0 +1,224 @@
+(dotted_identifier_list) @string
+
+; Methods
+; --------------------
+;; TODO: does not work
+;(function_type
+  ;name: (identifier) @method)
+(super) @function
+
+; Annotations
+; --------------------
+(annotation
+  name: (identifier) @attribute)
+(marker_annotation
+  name: (identifier) @attribute)
+
+; Operators and Tokens
+; --------------------
+(template_substitution
+  "$" @punctuation.special
+  "{" @punctuation.special
+  "}" @punctuation.special
+) @none
+
+(template_substitution
+  "$" @punctuation.special
+  (identifier_dollar_escaped) @variable
+) @none
+
+(escape_sequence) @string.escape
+
+[
+ "@"
+ "=>"
+ ".."
+ "??"
+ "=="
+ "?"
+ ":"
+ "&&"
+ "%"
+ "<"
+ ">"
+ "="
+ ">="
+ "<="
+ "||"
+ (increment_operator)
+ (is_operator)
+ (prefix_operator)
+ (equality_operator)
+ (additive_operator)
+] @operator
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+]  @punctuation.bracket
+
+; Delimiters
+; --------------------
+[
+  ";"
+  "."
+  ","
+] @punctuation.delimiter
+
+; Types
+; --------------------
+(class_definition
+  name: (identifier) @type)
+(constructor_signature
+  name: (identifier) @type)
+;; TODO: does not work
+;(type_identifier
+  ;(identifier) @type)
+(scoped_identifier
+  scope: (identifier) @type)
+(function_signature
+  name: (identifier) @method)
+(getter_signature
+  (identifier) @method)
+(setter_signature
+  name: (identifier) @method)
+(enum_declaration
+  name: (identifier) @type)
+(enum_constant
+  name: (identifier) @type)
+(type_identifier) @type
+(void_type) @type
+
+((scoped_identifier
+  scope: (identifier) @type
+  name: (identifier) @type)
+ (#match? @type "^[a-zA-Z]"))
+
+(type_identifier) @type
+
+; Variables
+; --------------------
+; var keyword
+(inferred_type) @keyword
+
+(const_builtin) @constant.builtin
+(final_builtin) @constant.builtin
+
+((identifier) @type
+ (#match? @type "^_?[A-Z]"))
+
+("Function" @type)
+
+; properties
+; TODO: add method/call_expression to grammar and
+; distinguish method call from variable access
+(unconditional_assignable_selector
+  (identifier) @property)
+
+; assignments
+(assignment_expression
+  left: (assignable_expression) @variable)
+
+(this) @variable.builtin
+
+; Parameters
+; --------------------
+(formal_parameter
+    name: (identifier) @parameter)
+
+(named_argument
+  (label (identifier) @parameter))
+
+; Literals
+; --------------------
+[
+    (hex_integer_literal)
+    (decimal_integer_literal)
+    (decimal_floating_point_literal)
+    ; TODO: inaccessbile nodes
+    ; (octal_integer_literal)
+    ; (hex_floating_point_literal)
+] @number
+
+(symbol_literal) @symbol
+(string_literal) @string
+(true) @boolean
+(false) @boolean
+(null_literal) @constant.builtin
+
+(documentation_comment) @comment
+(comment) @comment
+
+; Keywords
+; --------------------
+["import" "library" "export"] @include
+
+; Reserved words (cannot be used as identifiers)
+; TODO: "rethrow" @keyword
+[
+    ; "assert"
+    (case_builtin)
+    "extension"
+    "on"
+    "class"
+    "enum"
+    "extends"
+    "in"
+    "is"
+    "new"
+    "return"
+    "super"
+    "with"
+] @keyword
+
+
+; Built in identifiers:
+; alone these are marked as keywords
+[
+    "abstract"
+    "as"
+    "async"
+    "async*"
+    "yield"
+    "sync*"
+    "await"
+    "covariant"
+    "deferred"
+    "dynamic"
+    "external"
+    "factory"
+    "get"
+    "implements"
+    "interface"
+    "library"
+    "operator"
+    "mixin"
+    "part"
+    "set"
+    "show"
+    "static"
+    "typedef"
+] @keyword
+
+; when used as an identifier:
+((identifier) @variable.builtin
+ (#vim-match? @variable.builtin "^(abstract|as|covariant|deferred|dynamic|export|external|factory|Function|get|implements|import|interface|library|operator|mixin|part|set|static|typedef)$"))
+
+["if" "else" "switch" "default"] @conditional
+
+[
+  "try"
+  "throw"
+  "catch"
+  "finally"
+  (break_statement)
+] @exception
+
+["do" "while" "continue" "for"] @repeat
+
+; Error
+(ERROR) @error

package/out/dart/indents.scm

@@ -0,0 +1,49 @@
+[
+  (class_body)
+  (function_body)
+  (function_expression_body)
+  (declaration
+    (initializers))
+  (switch_block)
+  (formal_parameter_list)
+  (formal_parameter)
+  (list_literal)
+  (return_statement)
+  (arguments)
+  (try_statement)
+] @indent.begin
+
+(switch_block
+  (_) @indent.begin
+  (#set! indent.immediate 1)
+  (#set! indent.start_at_same_line 1))
+
+[
+  (switch_statement_case)
+  (switch_statement_default)
+] @indent.branch
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @indent.branch
+
+"}" @indent.end
+
+(return_statement
+  ";" @indent.end)
+
+(break_statement
+  ";" @indent.end)
+
+(comment) @indent.ignore
+
+; dedenting the else block is painfully slow; replace with simpler strategy
+; (if_statement) @indent.begin
+; (if_statement
+;   (block) @indent.branch)
+(if_statement) @indent.auto

package/out/dart/injections.scm

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

package/out/dart/locals.scm

@@ -0,0 +1,32 @@
+; Definitions
+(function_signature
+  name: (identifier) @local.definition.function)
+
+(formal_parameter
+  name: (identifier) @local.definition.parameter)
+
+(initialized_variable_definition
+  name: (identifier) @local.definition.var)
+
+(initialized_identifier
+  (identifier) @local.definition.var)
+
+(static_final_declaration
+  (identifier) @local.definition.var)
+
+; References
+(identifier) @local.reference
+
+; Scopes
+(class_definition
+  body: (_) @local.scope)
+
+[
+  (block)
+  (if_statement)
+  (for_statement)
+  (while_statement)
+  (try_statement)
+  (catch_clause)
+  (finally_clause)
+] @local.scope

package/out/desktop/folds.scm

@@ -0,0 +1 @@
+(group) @fold