ts-wasms 1.1.0 → 2.0.0

package/out/go/folds.scm

@@ -0,0 +1,19 @@
+[
+  (const_declaration)
+  (expression_switch_statement)
+  (expression_case)
+  (default_case)
+  (type_switch_statement)
+  (type_case)
+  (for_statement)
+  (func_literal)
+  (function_declaration)
+  (if_statement)
+  (import_declaration)
+  (method_declaration)
+  (type_declaration)
+  (var_declaration)
+  (composite_literal)
+  (literal_element)
+  (block)
+] @fold

package/out/go/indents.scm

@@ -0,0 +1,48 @@
+[
+  (import_declaration)
+  (const_declaration)
+  (var_declaration)
+  (type_declaration)
+  (func_literal)
+  (literal_value)
+  (expression_case)
+  (communication_case)
+  (type_case)
+  (default_case)
+  (block)
+  (call_expression)
+  (parameter_list)
+  (field_declaration_list)
+  (interface_type)
+] @indent.begin
+
+(literal_value
+  "}" @indent.branch)
+
+(block
+  "}" @indent.branch)
+
+(field_declaration_list
+  "}" @indent.branch)
+
+(interface_type
+  "}" @indent.branch)
+
+(const_declaration
+  ")" @indent.branch)
+
+(import_spec_list
+  ")" @indent.branch)
+
+(var_spec_list
+  ")" @indent.branch)
+
+[
+  "}"
+  ")"
+] @indent.end
+
+(parameter_list
+  ")" @indent.branch)
+
+(comment) @indent.ignore

package/out/go/injections.scm

@@ -0,0 +1,42 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+(call_expression
+  (selector_expression) @_function
+  (#any-of? @_function
+    "regexp.Match" "regexp.MatchReader" "regexp.MatchString" "regexp.Compile" "regexp.CompilePOSIX"
+    "regexp.MustCompile" "regexp.MustCompilePOSIX")
+  (argument_list
+    .
+    [
+      (raw_string_literal
+        (raw_string_literal_content) @injection.content)
+      (interpreted_string_literal
+        (interpreted_string_literal_content) @injection.content)
+    ]
+    (#set! injection.language "regex")))
+
+((comment) @injection.content
+  (#match? @injection.content "/\\*!([a-zA-Z]+:)?re2c")
+  (#set! injection.language "re2c"))
+
+((call_expression
+  function: (selector_expression
+    field: (field_identifier) @_method)
+  arguments: (argument_list
+    .
+    (interpreted_string_literal
+      (interpreted_string_literal_content) @injection.content)))
+  (#any-of? @_method "Printf" "Sprintf" "Fatalf" "Scanf" "Errorf" "Skipf" "Logf")
+  (#set! injection.language "printf"))
+
+((call_expression
+  function: (selector_expression
+    field: (field_identifier) @_method)
+  arguments: (argument_list
+    (_)
+    .
+    (interpreted_string_literal
+      (interpreted_string_literal_content) @injection.content)))
+  (#any-of? @_method "Fprintf" "Fscanf" "Appendf" "Sscanf")
+  (#set! injection.language "printf"))

package/out/go/locals.scm

@@ -0,0 +1,88 @@
+((function_declaration
+  name: (identifier) @local.definition.function) ; @function
+  )
+
+((method_declaration
+  name: (field_identifier) @local.definition.method) ; @function.method
+  )
+
+(short_var_declaration
+  left: (expression_list
+    (identifier) @local.definition.var))
+
+(var_spec
+  name: (identifier) @local.definition.var)
+
+(parameter_declaration
+  (identifier) @local.definition.var)
+
+(variadic_parameter_declaration
+  (identifier) @local.definition.var)
+
+(for_statement
+  (range_clause
+    left: (expression_list
+      (identifier) @local.definition.var)))
+
+(const_declaration
+  (const_spec
+    name: (identifier) @local.definition.var))
+
+(type_declaration
+  (type_spec
+    name: (type_identifier) @local.definition.type))
+
+; reference
+(identifier) @local.reference
+
+(type_identifier) @local.reference
+
+(field_identifier) @local.reference
+
+((package_identifier) @local.reference
+  (#set! reference.kind "namespace"))
+
+(package_clause
+  (package_identifier) @local.definition.namespace)
+
+(import_spec_list
+  (import_spec
+    name: (package_identifier) @local.definition.namespace))
+
+; Call references
+((call_expression
+  function: (identifier) @local.reference)
+  (#set! reference.kind "call"))
+
+((call_expression
+  function: (selector_expression
+    field: (field_identifier) @local.reference))
+  (#set! reference.kind "call"))
+
+((call_expression
+  function: (parenthesized_expression
+    (identifier) @local.reference))
+  (#set! reference.kind "call"))
+
+((call_expression
+  function: (parenthesized_expression
+    (selector_expression
+      field: (field_identifier) @local.reference)))
+  (#set! reference.kind "call"))
+
+; Scopes
+(func_literal) @local.scope
+
+(source_file) @local.scope
+
+(function_declaration) @local.scope
+
+(if_statement) @local.scope
+
+(block) @local.scope
+
+(expression_switch_statement) @local.scope
+
+(for_statement) @local.scope
+
+(method_declaration) @local.scope

package/out/graphql/indents.scm

@@ -0,0 +1,11 @@
+[
+  (definition)
+  (selection)
+] @indent.begin
+
+[
+  "{"
+  "}"
+] @indent.branch
+
+"}" @indent.end

package/out/graphql/injections.scm

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

package/out/groovy/folds.scm

@@ -0,0 +1,6 @@
+[
+  (argument_list)
+  (closure)
+  (list)
+  (map)
+] @fold

package/out/groovy/highlights.scm

@@ -0,0 +1,148 @@
+[
+  "!in"
+  "!instanceof"
+  "as"
+  "assert"
+  "case"
+  "catch"
+  "class"
+  "def"
+  "default"
+  "else"
+  "extends"
+  "finally"
+  "for"
+  "if"
+  "import"
+  "in"
+  "instanceof"
+  "package"
+  "pipeline"
+  "return"
+  "switch"
+  "try"
+  "while"
+  (break)
+  (continue)
+] @keyword
+
+[
+  "true"
+  "false"
+] @boolean
+
+(null) @constant
+"this" @variable.builtin
+
+[ 
+  "int"
+  "char"
+  "short"
+  "long"
+  "boolean"
+  "float"
+  "double"
+  "void"
+] @type.builtin
+
+[ 
+  "final"
+  "private"
+  "protected"
+  "public"
+  "static"
+  "synchronized"
+] @type.qualifier
+
+(comment) @comment
+(shebang) @comment
+
+(string) @string
+(string (escape_sequence) @operator)
+(string (interpolation ([ "$" ]) @operator))
+
+("(") @punctuation.bracket
+(")") @punctuation.bracket
+("[") @punctuation.bracket
+("]") @punctuation.bracket
+("{") @punctuation.bracket
+("}") @punctuation.bracket
+(":") @punctuation.delimiter
+(",") @punctuation.delimiter
+(".") @punctuation.delimiter
+
+(number_literal) @number
+(identifier) @variable
+((identifier) @variable.parameter
+  (#is? @variable.parameter "local.parameter"))
+
+((identifier) @constant
+  (#match? @constant "^[A-Z][A-Z_]+"))
+
+[ 
+  "%" "*" "/" "+" "-" "<<" ">>" ">>>" ".." "..<" "<..<" "<.." "<"
+  "<=" ">" ">=" "==" "!=" "<=>" "===" "!==" "=~" "==~" "&" "^" "|"
+  "&&" "||" "?:" "+" "*" ".&" ".@" "?." "*." "*" "*:" "++" "--" "!"
+] @operator
+
+(string ("/") @string)
+
+(ternary_op ([ "?" ":" ]) @operator)
+
+(map (map_item key: (identifier) @variable.parameter))
+
+(parameter type: (identifier) @type name: (identifier) @variable.parameter)
+(generic_param name: (identifier) @variable.parameter)
+
+(declaration type: (identifier) @type)
+(function_definition type: (identifier) @type)
+(function_declaration type: (identifier) @type)
+(class_definition name: (identifier) @type)
+(class_definition superclass: (identifier) @type)
+(generic_param superclass: (identifier) @type)
+
+(type_with_generics (identifier) @type)
+(type_with_generics (generics (identifier) @type))
+(generics [ "<" ">" ] @punctuation.bracket)
+(generic_parameters [ "<" ">" ] @punctuation.bracket)
+; TODO: Class literals with PascalCase
+
+(declaration ("=") @operator)
+(assignment ("=") @operator)
+
+
+(function_call 
+  function: (identifier) @function)
+(function_call
+  function: (dotted_identifier
+	  (identifier) @function . ))
+(function_call (argument_list
+		 (map_item key: (identifier) @variable.parameter)))
+(juxt_function_call 
+  function: (identifier) @function)
+(juxt_function_call
+  function: (dotted_identifier
+	  (identifier) @function . ))
+(juxt_function_call (argument_list 
+		      (map_item key: (identifier) @variable.parameter)))
+
+(function_definition 
+  function: (identifier) @function)
+(function_declaration 
+  function: (identifier) @function)
+
+(annotation) @function.macro
+(annotation (identifier) @function.macro)
+"@interface" @function.macro
+
+"pipeline" @keyword
+
+(groovy_doc) @comment.documentation
+(groovy_doc 
+  [
+    (groovy_doc_param)
+    (groovy_doc_throws)
+    (groovy_doc_tag)
+  ] @string.special)
+(groovy_doc (groovy_doc_param (identifier) @variable.parameter))
+(groovy_doc (groovy_doc_throws (identifier) @type))

package/out/groovy/indents.scm

@@ -0,0 +1,23 @@
+[
+  (closure)
+  (map)
+  (list)
+  (argument_list)
+  (parameter_list)
+  (for_parameters)
+] @indent.begin
+
+; (function_definition "(" @indent.begin)
+
+(closure "}" @indent.end)
+(argument_list ")" @indent.end)
+(for_parameters ")" @indent.end)
+((for_loop
+  body: (_) @_body) @indent.begin
+  (#not-has-type? @_body closure))
+; TODO: while, try
+
+(list "]" @indent.end)
+(map "]" @indent.end)
+
+[ "}" ")" "]" ] @indent.branch

package/out/groovy/injections.scm

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

package/out/groovy/locals.scm

@@ -0,0 +1,6 @@
+[
+  (function_definition)
+] @local.scope
+(parameter name: (identifier) @local.definition.parameter)
+
+(identifier) @local.reference

package/out/haskell/folds.scm

@@ -0,0 +1,6 @@
+[
+  (apply)
+  (do)
+  (function)
+  (import)+
+] @fold

package/out/hcl/folds.scm

@@ -0,0 +1,6 @@
+[
+  (comment)
+  (block)
+  (heredoc_template)
+  (object)
+] @fold

package/out/hcl/indents.scm

@@ -0,0 +1,16 @@
+[
+  (block)
+  (object)
+  (tuple)
+  (function_call)
+] @indent.begin
+
+[
+  "]"
+  ")"
+  "}"
+] @indent.branch @indent.end
+
+(comment) @indent.auto
+
+(ERROR) @indent.auto

package/out/hcl/injections.scm

@@ -0,0 +1,6 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+(heredoc_template
+  (template_literal) @injection.content
+  (heredoc_identifier) @injection.language)

package/out/html/folds.scm

@@ -0,0 +1,5 @@
+[
+  (element)
+  (style_element)
+  (script_element)
+] @fold

package/out/html/indents.scm

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

package/out/html/locals.scm

@@ -0,0 +1 @@
+(element) @local.scope

package/out/ini/folds.scm

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

package/out/ini/highlights.scm

@@ -0,0 +1,16 @@
+(section_name
+  (text) @type) ; consistency with toml
+
+(comment) @comment @spell
+
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+"=" @operator
+
+(setting
+  (setting_name) @property)
+
+; (setting_value) @none ; grammar does not support subtypes

package/out/ini/injections.scm

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

package/out/java/folds.scm

@@ -0,0 +1,8 @@
+[
+  (block)
+  (class_body)
+  (constructor_declaration)
+  (argument_list)
+  (annotation_argument_list)
+  (import_declaration)+
+] @fold

package/out/java/indents.scm

@@ -0,0 +1,40 @@
+; format-ignore
+[
+  ; ... refers to the portion that this indent query will have effects on
+  (class_body)                        ; { ... } of `class X`
+  (enum_body)                         ; { ... } of `enum X`
+  (interface_body)                    ; { ... } of `interface X`
+  (constructor_body)                  ; { `modifier` X() {...} } inside `class X`
+  (annotation_type_body)              ; { ... } of `@interface X`
+  (block)                             ; { ... } that's not mentioned in this scope
+  (switch_block)                      ; { ... } in `switch X`
+  (array_initializer)                 ; [1, 2]
+  (argument_list)                     ; foo(...)
+  (formal_parameters)                 ; method foo(...)
+  (annotation_argument_list)          ; @Annotation(...)
+  (element_value_array_initializer)   ; { a, b } inside @Annotation()
+] @indent.begin
+
+(expression_statement
+  (method_invocation) @indent.begin)
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @indent.branch
+
+(annotation_argument_list
+  ")" @indent.end) ; This should be a special cased as `()` here doesn't have ending `;`
+
+"}" @indent.end
+
+(line_comment) @indent.ignore
+
+[
+  (ERROR)
+  (block_comment)
+] @indent.auto

package/out/java/injections.scm

@@ -0,0 +1,31 @@
+([
+  (block_comment)
+  (line_comment)
+] @injection.content
+  (#set! injection.language "comment"))
+
+((block_comment) @injection.content
+  (#lua-match? @injection.content "/[*][*][%s]")
+  (#set! injection.language "javadoc"))
+
+; markdown-style javadocs https://openjdk.org/jeps/467
+((line_comment) @injection.content
+  (#lua-match? @injection.content "^///%s")
+  (#set! injection.language "javadoc"))
+
+((method_invocation
+  name: (identifier) @_method
+  arguments: (argument_list
+    .
+    (string_literal
+      .
+      (_) @injection.content)))
+  (#any-of? @_method "format" "printf")
+  (#set! injection.language "printf"))
+
+((method_invocation
+  object: (string_literal
+    (string_fragment) @injection.content)
+  name: (identifier) @_method)
+  (#eq? @_method "formatted")
+  (#set! injection.language "printf"))

package/out/java/locals.scm

@@ -0,0 +1,100 @@
+; SCOPES
+; declarations
+(program) @local.scope
+
+(class_declaration
+  body: (_) @local.scope)
+
+(record_declaration
+  body: (_) @local.scope)
+
+(enum_declaration
+  body: (_) @local.scope)
+
+(lambda_expression) @local.scope
+
+(enhanced_for_statement) @local.scope
+
+; block
+(block) @local.scope
+
+; if/else
+(if_statement) @local.scope ; if+else
+
+(if_statement
+  consequence: (_) @local.scope) ; if body in case there are no braces
+
+(if_statement
+  alternative: (_) @local.scope) ; else body in case there are no braces
+
+; try/catch
+(try_statement) @local.scope ; covers try+catch, individual try and catch are covered by (block)
+
+(catch_clause) @local.scope ; needed because `Exception` variable
+
+; loops
+(for_statement) @local.scope ; whole for_statement because loop iterator variable
+
+(for_statement
+  ; "for" body in case there are no braces
+  body: (_) @local.scope)
+
+(do_statement
+  body: (_) @local.scope)
+
+(while_statement
+  body: (_) @local.scope)
+
+; Functions
+(constructor_declaration) @local.scope
+
+(method_declaration) @local.scope
+
+; DEFINITIONS
+(package_declaration
+  (identifier) @local.definition.namespace)
+
+(class_declaration
+  name: (identifier) @local.definition.type)
+
+(record_declaration
+  name: (identifier) @local.definition.type)
+
+(enum_declaration
+  name: (identifier) @local.definition.enum)
+
+(method_declaration
+  name: (identifier) @local.definition.method)
+
+(local_variable_declaration
+  declarator: (variable_declarator
+    name: (identifier) @local.definition.var))
+
+(enhanced_for_statement
+  ; for (var item : items) {
+  name: (identifier) @local.definition.var)
+
+(formal_parameter
+  name: (identifier) @local.definition.parameter)
+
+(catch_formal_parameter
+  name: (identifier) @local.definition.parameter)
+
+(inferred_parameters
+  (identifier) @local.definition.parameter) ; (x,y) -> ...
+
+(lambda_expression
+  parameters: (identifier) @local.definition.parameter) ; x -> ...
+
+((scoped_identifier
+  (identifier) @local.definition.import)
+  (#has-ancestor? @local.definition.import import_declaration))
+
+(field_declaration
+  declarator: (variable_declarator
+    name: (identifier) @local.definition.field))
+
+; REFERENCES
+(identifier) @local.reference
+
+(type_identifier) @local.reference

package/out/javascript/folds.scm

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

package/out/javascript/indents.scm

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

package/out/json/folds.scm

@@ -0,0 +1,5 @@
+[
+  (pair)
+  (object)
+  (array)
+] @fold