ts-wasms 1.0.2

package/out/scala/highlights.scm

@@ -0,0 +1,260 @@
+; CREDITS @stumash (stuart.mashaal@gmail.com)
+
+(field_expression field: (identifier) @property)
+(field_expression value: (identifier) @type
+ (#match? @type "^[A-Z]"))
+
+(type_identifier) @type
+
+(class_definition
+  name: (identifier) @type)
+
+(enum_definition
+  name: (identifier) @type)
+
+(object_definition
+  name: (identifier) @type)
+
+(trait_definition
+  name: (identifier) @type)
+
+(full_enum_case
+  name: (identifier) @type)
+
+(simple_enum_case
+  name: (identifier) @type)
+
+;; variables
+
+(class_parameter
+  name: (identifier) @parameter)
+
+(self_type (identifier) @parameter)
+
+(interpolation (identifier) @none)
+(interpolation (block) @none)
+
+;; types
+
+(type_definition
+  name: (type_identifier) @type.definition)
+
+;; val/var definitions/declarations
+
+(val_definition
+  pattern: (identifier) @variable)
+
+(var_definition
+  pattern: (identifier) @variable)
+
+(val_declaration
+  name: (identifier) @variable)
+
+(var_declaration
+  name: (identifier) @variable)
+
+; imports/exports
+
+(import_declaration
+  path: (identifier) @namespace)
+((stable_identifier (identifier) @namespace))
+
+((import_declaration
+  path: (identifier) @type) (#match? @type "^[A-Z]"))
+((stable_identifier (identifier) @type) (#match? @type "^[A-Z]"))
+
+(export_declaration
+  path: (identifier) @namespace)
+((stable_identifier (identifier) @namespace))
+
+((export_declaration
+  path: (identifier) @type) (#match? @type "^[A-Z]"))
+((stable_identifier (identifier) @type) (#match? @type "^[A-Z]"))
+
+((namespace_selectors (identifier) @type) (#match? @type "^[A-Z]"))
+
+; method invocation
+
+(call_expression
+  function: (identifier) @function.call)
+
+(call_expression
+  function: (operator_identifier) @function.call)
+
+(call_expression
+  function: (field_expression
+    field: (identifier) @method.call))
+
+((call_expression
+   function: (identifier) @constructor)
+ (#match? @constructor "^[A-Z]"))
+
+(generic_function
+  function: (identifier) @function.call)
+
+(interpolated_string_expression
+  interpolator: (identifier) @function.call)
+
+; function definitions
+
+(function_definition
+  name: (identifier) @function)
+
+(parameter
+  name: (identifier) @parameter)
+
+(binding
+  name: (identifier) @parameter)
+
+; method definition
+
+(function_declaration
+      name: (identifier) @method)
+
+(function_definition
+      name: (identifier) @method)
+
+; expressions
+
+(infix_expression operator: (identifier) @operator)
+(infix_expression operator: (operator_identifier) @operator)
+(infix_type operator: (operator_identifier) @operator)
+(infix_type operator: (operator_identifier) @operator)
+
+; literals
+
+(boolean_literal) @boolean
+(integer_literal) @number
+(floating_point_literal) @float
+
+[
+  (string)
+  (character_literal)
+  (interpolated_string_expression)
+] @string
+
+(interpolation "$" @punctuation.special)
+
+;; keywords
+
+(opaque_modifier) @type.qualifier
+(infix_modifier) @keyword
+(transparent_modifier) @type.qualifier
+(open_modifier) @type.qualifier
+
+[
+  "case"
+  "class"
+  "enum"
+  "extends"
+  "derives"
+  "finally"
+;; `forSome` existential types not implemented yet
+;; `macro` not implemented yet
+  "object"
+  "override"
+  "package"
+  "trait"
+  "type"
+  "val"
+  "var"
+  "with"
+  "given"
+  "using"
+  "end"
+  "implicit"
+  "extension"
+  "with"
+] @keyword
+
+[
+  "abstract"
+  "final"
+  "lazy"
+  "sealed"
+  "private"
+  "protected"
+] @type.qualifier
+
+(inline_modifier) @storageclass
+
+(null_literal) @constant.builtin
+
+(wildcard) @parameter
+
+(annotation) @attribute
+
+;; special keywords
+
+"new" @keyword.operator
+
+[
+  "else"
+  "if"
+  "match"
+  "then"
+] @conditional
+
+[
+ "("
+ ")"
+ "["
+ "]"
+ "{"
+ "}"
+]  @punctuation.bracket
+
+[
+ "."
+ ","
+] @punctuation.delimiter
+
+[
+  "do"
+  "for"
+  "while"
+  "yield"
+] @repeat
+
+"def" @keyword.function
+
+[
+ "=>"
+ "<-"
+ "@"
+] @operator
+
+["import" "export"] @include
+
+[
+  "try"
+  "catch"
+  "throw"
+] @exception
+
+"return" @keyword.return
+
+(comment) @spell @comment
+(block_comment) @spell @comment
+
+;; `case` is a conditional keyword in case_block
+
+(case_block
+  (case_clause ("case") @conditional))
+(indented_cases
+  (case_clause ("case") @conditional))
+
+(operator_identifier) @operator
+
+((identifier) @type (#match? @type "^[A-Z]"))
+((identifier) @variable.builtin
+ (#match? @variable.builtin "^this$"))
+
+(
+  (identifier) @function.builtin
+  (#match? @function.builtin "^super$")
+)
+
+;; Scala CLI using directives
+(using_directive_key) @parameter
+(using_directive_value) @string

package/out/scala/indents.scm

@@ -0,0 +1,30 @@
+; These indent queries adhere to nvim-tree-sytter syntax.
+; See `nvim-tree-sitter-indentation-mod` vim help page.
+
+[
+  (template_body)
+  (block)
+  (parameters)
+  (arguments)
+  (match_expression)
+  (splice_expression)
+  (import_declaration)
+  (function_definition)
+  (ERROR ":")
+  (ERROR "=")
+  ("match")
+  (":")
+  ("=")
+] @indent.begin
+
+(arguments ")" @indent.end)
+
+"}" @indent.end
+
+"end" @indent.end
+
+[
+  ")"
+  "]"
+  "}"
+] @indent.branch

package/out/scala/locals.scm

@@ -0,0 +1,30 @@
+(template_body) @local.scope
+(lambda_expression) @local.scope
+
+
+(function_declaration
+      name: (identifier) @local.definition) @local.scope
+
+(function_definition
+      name: (identifier) @local.definition)
+
+(parameter
+  name: (identifier) @local.definition)
+
+(binding
+  name: (identifier) @local.definition)
+
+(val_definition
+  pattern: (identifier) @local.definition)
+
+(var_definition
+  pattern: (identifier) @local.definition)
+
+(val_declaration
+  name: (identifier) @local.definition)
+
+(var_declaration
+  name: (identifier) @local.definition)
+
+(identifier) @local.reference
+

package/out/scala/tags.scm

@@ -0,0 +1,66 @@
+; Definitions
+
+(package_clause
+  name: (package_identifier) @name) @definition.module
+
+(trait_definition
+  name: (identifier) @name) @definition.interface
+
+(enum_definition
+  name: (identifier) @name) @definition.enum
+
+(simple_enum_case
+  name: (identifier) @name) @definition.class
+
+(full_enum_case
+  name: (identifier) @name) @definition.class
+
+(class_definition
+  name: (identifier) @name) @definition.class
+
+(object_definition
+  name: (identifier) @name) @definition.object
+
+(function_definition
+  name: (identifier) @name) @definition.function
+
+(val_definition
+  pattern: (identifier) @name) @definition.variable
+
+(given_definition
+  name: (identifier) @name) @definition.variable
+
+(var_definition
+  pattern: (identifier) @name) @definition.variable
+
+(val_declaration
+  name: (identifier) @name) @definition.variable
+
+(var_declaration
+  name: (identifier) @name) @definition.variable
+
+(type_definition
+  name: (type_identifier) @name) @definition.type
+
+(class_parameter
+  name: (identifier) @name) @definition.property
+
+; References 
+
+(call_expression
+  (identifier) @name) @reference.call
+
+(instance_expression
+  (type_identifier) @name) @reference.interface
+
+(instance_expression
+  (generic_type
+    (type_identifier) @name)) @reference.interface
+
+(extends_clause
+  (type_identifier) @name) @reference.class
+
+(extends_clause
+  (generic_type
+    (type_identifier) @name)) @reference.class
+

package/out/swift/folds.scm

@@ -0,0 +1,35 @@
+; format-ignore
+[
+  (protocol_body)               ; protocol Foo { ... }
+  (class_body)                  ; class Foo { ... }
+  (enum_class_body)             ; enum Foo { ... }
+  (function_body)               ; func Foo (...) {...}
+  (computed_property)           ; { ... }
+
+  (computed_getter)             ; get { ... }
+  (computed_setter)             ; set { ... }
+
+  (do_statement)
+  (if_statement)
+  (for_statement)
+  (switch_statement)
+  (while_statement)
+  (guard_statement)
+  (switch_entry)
+
+  (type_parameters)             ; x<Foo>
+  (tuple_type)                  ; (...)
+  (array_type)                  ; [String]
+  (dictionary_type)             ; [Foo: Bar]
+
+  (call_expression)             ; callFunc(...)
+  (tuple_expression)            ; ( foo + bar )
+  (array_literal)               ; [ foo, bar ]
+  (dictionary_literal)          ; [ foo: bar, x: y ]
+  (lambda_literal)
+  (willset_didset_block)
+  (willset_clause)
+  (didset_clause)
+
+  (import_declaration)+
+] @fold