ts-wasms 1.0.2 → 1.0.3

package/README.md

@@ -0,0 +1,33 @@
+# ts-wasms
+Prebuilt WASM binaries for tree-sitter's language parsers.
+You can find a list of supported packages [here](https://app.unpkg.com/ts-wasms/files/out)
+
+## Installation
+```bash
+pnpm add ts-wasms
+```
+
+## Usage
+```ts
+import pythonWasm from "ts-wasms/out/python/tree-sitter-python.wasm"
+import pythonHighlights from "ts-wasms/out/python/highlights.scm"
+```
+
+Each language directory includes a `tree-sitter-<lang>.wasm` file but may also include:
+- `highlights.scm`
+- `injections.scm`
+- `locals.scm`
+- `tags.scm`
+- `folds.scm`
+- `indents.scm`
+
+```txt
+out/python/
+├── tree-sitter-python.wasm
+├── highlights.scm
+└── tags.scm
+```
+
+## Licenses
+Licenses belong to their respective upstream grammar authors, however this repo is MIT licensed.
+(If you have a problem with this licensing, please open an issue.)

package/out/clojure/highlights.scm

@@ -0,0 +1,29 @@
+;; Literals
+
+(num_lit) @number
+
+[
+  (char_lit)
+  (str_lit)
+] @string
+
+[
+ (bool_lit)
+ (nil_lit)
+] @constant.builtin
+
+(kwd_lit) @constant
+
+;; Comments
+
+(comment) @comment
+
+;; Treat quasiquotation as operators for the purpose of highlighting.
+
+[
+ "'"
+ "`"
+ "~"
+ "@"
+ "~@"
+] @operator

package/out/clojurescript/highlights.scm

@@ -0,0 +1,29 @@
+;; Literals
+
+(num_lit) @number
+
+[
+  (char_lit)
+  (str_lit)
+] @string
+
+[
+ (bool_lit)
+ (nil_lit)
+] @constant.builtin
+
+(kwd_lit) @constant
+
+;; Comments
+
+(comment) @comment
+
+;; Treat quasiquotation as operators for the purpose of highlighting.
+
+[
+ "'"
+ "`"
+ "~"
+ "@"
+ "~@"
+] @operator

package/out/commonlisp/tags.scm

@@ -0,0 +1,122 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; Function Definitions ;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun_header
+  function_name: (sym_lit) @name) @definition.function
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; Function Calls ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;; Basically, we consider every list literal with symbol as the
+;;; first element to be a call to a function named by that element.
+;;; But we must exclude some cases. Note, tree-sitter @ignore
+;;; cases only work if they are declared before the cases
+;;; we want to include.
+
+;; Exclude lambda lists for function definitions
+;; For example:
+;;
+;;    (defun my-func (arg1 arg2) ...)
+;;
+;; do not treat (arg1 arg2) as a call of function arg1
+;;
+(defun_header
+  lambda_list: (list_lit . [(sym_lit) (package_lit)] @ignore))
+
+;; Similar to the above, but for
+;;
+;;     (defmethod m ((type1 param1) (type2 param2)) ...)
+;;
+;; where list literals having symbol as their first element
+;; are nested inside the lambda list.
+(defun_header
+  lambda_list: (list_lit (list_lit . [(sym_lit) (package_lit)] @ignore)))
+
+;;
+;;      (let ((var ...) (var2 ...)) ...)
+;;
+;; - exclude var, var2
+;; - the same for let*, flet, labels, macrolet, symbol-macrolet
+(list_lit . [(sym_lit) (package_lit)] @name
+          . (list_lit (list_lit . [(sym_lit) (package_lit)] @ignore))
+          (#match? @name
+                   "(?i)^(cl:)?(let|let\\*|flet|labels|macrolet|symbol-macrolet)$")
+  )
+
+;; TODO:
+;;     - exclude also:
+;;       - (defclass name (parent parent2)
+;;           ((slot1 ...)
+;;            (slot2 ...))
+;;              exclude the parent, slot1, slot2
+;;       - (flet ((func-1 (param1 param2))) ...)
+;;           - we already exclude func-1, but param1 is still recognized
+;;             as a function call - exclude it too
+;;           - the same for labels
+;;           - the same macrolet
+;;       - what else?
+;;         (that's a non-goal to completely support all macros
+;;          and special operators, but every one we support
+;;          makes the solution a little bit better)
+;;     - (flet ((func-1 (param1 param2))) ...)
+;;       - instead of simply excluding it, as we do today,
+;;         tag func-1 as @local.definition.function (I suppose)
+;;       - the same for labels, macrolet
+;;     - @local.scope for let, let*, flet, labels, macrolet
+;;       - I guess the whole span of the scope text,
+;;         till the closing paren, should be tagged as @local.scope;
+;;         Hopefully, combined with @local.definition.function
+;;         withing the scope, the usual  @reference.call within
+;;         that scope will refer to the local definition,
+;;         and there will be no need to use @local.reference.call
+;;         (which is more difficult to implement).
+;;       - When implementing, remeber the scope rules differences
+;;         of let vs let*, flet vs labels.
+
+
+;; Inlclude all other cases - list literal with symbol as the
+;; first element
+(list_lit . [(sym_lit) (package_lit)] @name) @reference.call
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; classes
+
+(list_lit . [(sym_lit) (package_lit)] @ignore
+          . [(sym_lit) (package_lit)] @name
+  (#match? @ignore "(?i)^(cl:)?defclass$")
+          ) @definition.class
+
+(list_lit . [(sym_lit) (package_lit)] @ignore
+          . (quoting_lit [(sym_lit) (package_lit)] @name)
+  (#match? @ignore "(?i)^(cl:)?make-instance$")
+          ) @reference.class
+
+;;; TODO:
+;;  - @reference.class for base classes
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; TODO:
+;; - Symbols referenced in defpackage
+;;
+;;       (defpackage ...
+;;         (:export (symbol-a :symbol-b #:symbol-c "SYMBOL-D")))
+;;
+;;   The goal is to allow quick navigation from the API
+;;   overview in the form of defpackage, to the definition
+;;   where user can read parameters, docstring, ect.
+;;   - The @name must not include the colon, or sharpsign colon, quotes,
+;;     just symbol-a, symbol-b, symbol-c, sybmol-d
+;;   - Downcase the names specified as stirng literals?
+;;     ("SYMBOL-D" -> symbol-d)
+;;   - We don't know if the exported symbol is a function, variable,
+;;     class or something else. The oficial doc
+;;     (https://tree-sitter.github.io/tree-sitter/code-navigation-systems)
+;;     does not even suggest a tag for variable reference.
+;;     (Although in practice, the `tree-sitter tags` command
+;;     allows any @reference.* and @definition.* tags)
+;;     Probably it's better to just use @reference.call for all
+;;     the symbols in the :export clause.
+;;
+;; - The same for the export function call:
+;; 
+;;       (export '(symbol-a :symbol-b #:symbol-c "SYMBOL-D"))

package/out/elm/highlights.scm

@@ -0,0 +1,76 @@
+; Keywords
+[
+    "if"
+    "then"
+    "else"
+    "let"
+    "in"
+ ] @keyword.control.elm
+(case) @keyword.control.elm
+(of) @keyword.control.elm
+
+(colon) @keyword.other.elm
+(backslash) @keyword.other.elm
+(as) @keyword.other.elm
+(port) @keyword.other.elm
+(exposing) @keyword.other.elm
+(alias) @keyword.other.elm
+(infix) @keyword.other.elm
+
+(arrow) @keyword.operator.arrow.elm
+
+(port) @keyword.other.port.elm
+
+(type_annotation(lower_case_identifier) @function.elm)
+(port_annotation(lower_case_identifier) @function.elm)
+(function_declaration_left(lower_case_identifier) @function.elm)
+(function_call_expr target: (value_expr) @function.elm)
+
+(field_access_expr(value_expr(value_qid)) @local.function.elm)
+(lower_pattern) @local.function.elm
+(record_base_identifier) @local.function.elm
+
+
+(operator_identifier) @keyword.operator.elm
+(eq) @keyword.operator.assignment.elm
+
+
+"(" @punctuation.section.braces
+")" @punctuation.section.braces
+
+"|" @keyword.other.elm
+"," @punctuation.separator.comma.elm
+
+(import) @meta.import.elm
+(module) @keyword.other.elm
+
+(number_constant_expr) @constant.numeric.elm
+
+
+(type) @keyword.type.elm
+
+(type_declaration(upper_case_identifier) @storage.type.elm)
+(type_ref) @storage.type.elm
+(type_alias_declaration name: (upper_case_identifier) @storage.type.elm)
+
+(union_variant(upper_case_identifier) @union.elm)
+(union_pattern) @union.elm
+(value_expr(upper_case_qid(upper_case_identifier)) @union.elm)
+
+; comments
+(line_comment) @comment.elm
+(block_comment) @comment.elm
+
+; strings
+(string_escape) @character.escape.elm
+
+(open_quote) @string.elm
+(close_quote) @string.elm
+(regular_string_part) @string.elm
+
+(open_char) @char.elm
+(close_char) @char.elm
+
+
+; glsl
+(glsl_content) @source.glsl

package/out/elm/injections.scm

@@ -0,0 +1,4 @@
+; Parse glsl where defined
+
+((glsl_content) @injection.content
+ (#set! injection.language "glsl"))

package/out/elm/locals.scm

@@ -0,0 +1,15 @@
+
+(value_declaration) @local.scope
+(type_alias_declaration) @local.scope
+(type_declaration) @local.scope
+(type_annotation) @local.scope
+(port_annotation) @local.scope
+(infix_declaration) @local.scope
+(let_in_expr) @local.scope
+
+(function_declaration_left (lower_pattern (lower_case_identifier)) @local.definition)
+(function_declaration_left (lower_case_identifier) @local.definition)
+
+(value_expr(value_qid(upper_case_identifier)) @local.reference)
+(value_expr(value_qid(lower_case_identifier)) @local.reference)
+(type_ref (upper_case_qid) @local.reference)

package/out/elm/tags.scm

@@ -0,0 +1,19 @@
+(value_declaration (function_declaration_left (lower_case_identifier) @name)) @definition.function
+
+(function_call_expr (value_expr (value_qid) @name)) @reference.function
+(exposed_value (lower_case_identifier) @name) @reference.function
+(type_annotation ((lower_case_identifier) @name) (colon)) @reference.function
+
+(type_declaration ((upper_case_identifier) @name) ) @definition.type
+
+(type_ref (upper_case_qid (upper_case_identifier) @name)) @reference.type
+(exposed_type (upper_case_identifier) @name) @reference.type
+
+(type_declaration (union_variant (upper_case_identifier) @name)) @definition.union
+
+(value_expr (upper_case_qid (upper_case_identifier) @name)) @reference.union
+
+
+(module_declaration 
+    (upper_case_qid (upper_case_identifier)) @name
+) @definition.module

package/out/erlang/highlights.scm

@@ -0,0 +1,230 @@
+;; Copyright (c) Facebook, Inc. and its affiliates.
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;; ---------------------------------------------------------------------
+
+;; Based initially on the contents of https://github.com/WhatsApp/tree-sitter-erlang/issues/2 by @Wilfred
+;; and https://github.com/the-mikedavis/tree-sitter-erlang/blob/main/queries/highlights.scm
+;;
+;; The tests are also based on those in
+;; https://github.com/the-mikedavis/tree-sitter-erlang/tree/main/test/highlight
+;;
+
+;; Last match wins in this file.
+;; As of https://github.com/tree-sitter/tree-sitter/blob/master/CHANGELOG.md#breaking-1
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Primitive types
+(string) @string
+(char) @constant
+(integer) @number
+(var) @variable
+(atom) @string.special.symbol
+
+;;; Comments
+((var) @comment.discard
+ (#match? @comment.discard "^_"))
+
+(dotdotdot) @comment.discard
+(comment) @comment
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Functions
+(fa fun: (atom) @function)
+(type_name name: (atom) @function)
+(call expr: (atom) @function)
+(function_clause name: (atom) @function)
+(internal_fun fun: (atom) @function)
+
+;; This is a fudge, we should check that the operator is '/'
+;; But our grammar does not (currently) provide it
+(binary_op_expr lhs: (atom) @function rhs: (integer))
+
+;; Others
+(remote_module module: (atom) @module)
+(remote fun: (atom) @function)
+(macro_call_expr name: (var) @constant)
+(macro_call_expr name: (var) @keyword.directive args: (_) )
+(macro_call_expr name: (atom) @keyword.directive)
+(record_field_name name: (atom) @property)
+(record_name name: (atom) @type)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Attributes
+
+;; module attribute
+(module_attribute
+  name: (atom) @module)
+
+;; behaviour
+(behaviour_attribute name: (atom) @module)
+
+;; export
+
+;; Import attribute
+(import_attribute
+    module: (atom) @module)
+
+;; export_type
+
+;; optional_callbacks
+
+;; compile
+(compile_options_attribute
+    options: (tuple
+      expr: (atom)
+      expr: (list
+        exprs: (binary_op_expr
+          lhs: (atom)
+          rhs: (integer)))))
+
+;; file attribute
+
+;; record
+(record_decl name: (atom) @type)
+(record_decl name: (macro_call_expr name: (var) @constant))
+(record_field name: (atom) @property)
+
+;; type alias
+
+;; opaque
+
+;; Spec attribute
+(spec fun: (atom) @function)
+(spec
+  module: (module name: (atom) @module)
+  fun: (atom) @function)
+
+;; callback
+(callback fun: (atom) @function)
+
+;; wild attribute
+(wild_attribute name: (attr_name name: (atom) @keyword))
+
+;; fun decl
+
+;; include/include_lib
+
+;; ifdef/ifndef
+(pp_ifdef name: (_) @keyword.directive)
+(pp_ifndef name: (_) @keyword.directive)
+
+;; define
+(pp_define
+    lhs: (macro_lhs
+      name: (var) @constant))
+(pp_define
+    lhs: (macro_lhs
+      name: (_) @keyword.directive
+      args: (var_args args: (var))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Reserved words
+[ "after"
+  "and"
+  "band"
+  "begin"
+  "behavior"
+  "behaviour"
+  "bnot"
+  "bor"
+  "bsl"
+  "bsr"
+  "bxor"
+  "callback"
+  "case"
+  "catch"
+  "compile"
+  "define"
+  "div"
+  "elif"
+  "else"
+  "end"
+  "endif"
+  "export"
+  "export_type"
+  "file"
+  "fun"
+  "if"
+  "ifdef"
+  "ifndef"
+  "import"
+  "include"
+  "include_lib"
+  "module"
+  "of"
+  "opaque"
+  "optional_callbacks"
+  "or"
+  "receive"
+  "record"
+  "spec"
+  "try"
+  "type"
+  "undef"
+  "unit"
+  "when"
+  "xor"] @keyword
+
+["andalso" "orelse"] @keyword.operator
+
+;; Punctuation
+["," "." ";"] @punctuation.delimiter
+["(" ")" "{" "}" "[" "]" "<<" ">>"] @punctuation.bracket
+
+;; Operators
+["!"
+ "->"
+ "<-"
+ "#"
+ "::"
+ ":>"
+ "|"
+ ":"
+ "="
+ "||"
+
+ "+"
+ "-"
+ "bnot"
+ "not"
+
+ "/"
+ "*"
+ "div"
+ "rem"
+ "band"
+ "and"
+
+ "+"
+ "-"
+ "bor"
+ "bxor"
+ "bsl"
+ "bsr"
+ "or"
+ "xor"
+
+ "++"
+ "--"
+
+ "=="
+ "/="
+ "=<"
+ "<"
+ ">="
+ ">"
+ "=:="
+ "=/="
+ ] @operator