src-mcp 1.0.1

package/assets/queries/rust/injections.scm

@@ -0,0 +1,170 @@
+([(line_comment !doc) (block_comment !doc)] @injection.content
+ (#set! injection.language "comment"))
+
+((doc_comment) @injection.content
+ (#set! injection.language "markdown-rustdoc")
+ (#set! injection.combined))
+
+((macro_invocation
+  (token_tree) @injection.content)
+ (#set! injection.language "rust")
+ (#set! injection.include-children))
+
+((macro_rule
+  (token_tree) @injection.content)
+ (#set! injection.language "rust")
+ (#set! injection.include-children))
+
+((macro_invocation
+   macro:
+     [
+       (scoped_identifier
+         name: (_) @_macro_name)
+       (identifier) @_macro_name
+     ]
+   (token_tree) @injection.content)
+ (#eq? @_macro_name "html")
+ (#set! injection.language "html")
+ (#set! injection.include-children))
+
+((macro_invocation
+   macro:
+     [
+       (scoped_identifier
+         name: (_) @_macro_name)
+       (identifier) @_macro_name
+     ]
+   (token_tree) @injection.content)
+ (#eq? @_macro_name "slint")
+ (#set! injection.language "slint")
+ (#set! injection.include-children))
+
+((macro_invocation
+   macro:
+     [
+       (scoped_identifier name: (_) @_macro_name)
+       (identifier) @_macro_name
+     ]
+   (token_tree
+     (token_tree . "{" "}" .) @injection.content))
+ (#eq? @_macro_name "json")
+ (#set! injection.language "json")
+ (#set! injection.include-children))
+
+(call_expression
+  function: (scoped_identifier
+    path: (identifier) @_regex (#any-of? @_regex "Regex" "RegexBuilder")
+    name: (identifier) @_new (#eq? @_new "new"))
+  arguments:
+    (arguments
+      [
+        (string_literal (string_content) @injection.content)
+        (raw_string_literal (string_content) @injection.content)
+      ])
+  (#set! injection.language "regex"))
+
+(call_expression
+  function: (scoped_identifier
+    path: (scoped_identifier (identifier) @_regex (#any-of? @_regex "Regex" "RegexBuilder") .)
+    name: (identifier) @_new (#eq? @_new "new"))
+  arguments:
+    (arguments
+      [
+        (string_literal (string_content) @injection.content)
+        (raw_string_literal (string_content) @injection.content)
+      ])
+  (#set! injection.language "regex"))
+
+; Highlight SQL in `sqlx::query!()`, `sqlx::query_scalar!()`, and `sqlx::query_scalar_unchecked!()`
+(macro_invocation
+  macro: (scoped_identifier
+    path: (identifier) @_sqlx (#eq? @_sqlx "sqlx")
+    name: (identifier) @_query (#match? @_query "^query(_scalar|_scalar_unchecked)?$"))
+  (token_tree
+    ; Only the first argument is SQL
+    .
+    [
+      (string_literal (string_content) @injection.content)
+      (raw_string_literal (string_content) @injection.content)
+    ]
+  )
+  (#set! injection.language "sql"))
+
+; Highlight SQL in `sqlx::query_as!()` and `sqlx::query_as_unchecked!()`
+(macro_invocation
+  macro: (scoped_identifier
+    path: (identifier) @_sqlx (#eq? @_sqlx "sqlx")
+    name: (identifier) @_query_as (#match? @_query_as "^query_as(_unchecked)?$"))
+  (token_tree
+    ; Only the second argument is SQL
+    .
+    ; Allow anything as the first argument in case the user has lower case type
+    ; names for some reason
+    (_)
+    [
+      (string_literal (string_content) @injection.content)
+      (raw_string_literal (string_content) @injection.content)
+    ]
+  )
+  (#set! injection.language "sql"))
+
+; Special language `tree-sitter-rust-format-args` for Rust macros,
+; which use `format_args!` under the hood and therefore have
+; the `format_args!` syntax.
+;
+; This language is injected into a hard-coded set of macros.
+(
+  (macro_invocation
+    macro:
+      [
+        (scoped_identifier
+          name: (_) @_macro_name)
+        (identifier) @_macro_name
+      ]
+    (token_tree) @injection.content
+  )
+  (#any-of? @_macro_name
+    ; 1st argument is `format_args!`
+
+    ; std
+    "print" "println" "eprint" "eprintln"
+    "format" "format_args" "todo" "panic"
+    "unreachable" "unimplemented" "compile_error"
+    ; log
+    "crit" "trace" "debug" "info" "warn" "error"
+    ; anyhow
+    "anyhow" "bail"
+    ; syn
+    "format_ident"
+    ; indoc
+    "formatdoc" "printdoc" "eprintdoc" "writedoc"
+    ; iced
+    "text"
+    ; ratatui
+    "span"
+    ; eyre
+    "eyre"
+    ; miette
+    "miette"
+
+    ; 2nd argument is `format_args!`
+
+    ; std
+    "write" "writeln" "assert" "debug_assert"
+    ; defmt
+    "expect" "unwrap"
+    ; ratatui
+    "span"
+
+    ; 3rd argument is `format_args!`
+
+    ; std
+    "assert_eq" "debug_assert_eq" "assert_ne" "debug_assert_ne"
+
+    ; Dioxus's rsx! macro accepts string interpolation in all
+    ; strings, across the entire token tree
+    "rsx"
+  )
+  (#set! injection.language "rust-format-args-macro")
+  (#set! injection.include-children)
+)

package/assets/queries/rust/locals.scm

@@ -0,0 +1,28 @@
+; Scopes
+
+[
+  (function_item)
+  (struct_item)
+  (enum_item)
+  (union_item)
+  (type_item)
+  (trait_item)
+  (impl_item)
+  (closure_expression)
+  (block)
+] @local.scope
+
+; Definitions
+
+(function_item
+  (parameters
+    (parameter
+      pattern: (identifier) @local.definition.variable.parameter)))
+
+(closure_parameters (identifier) @local.definition.variable.parameter)
+
+; References
+(identifier) @local.reference
+; lifetimes / labels
+(lifetime (identifier) @label)
+(label (identifier) @label)

package/assets/queries/rust/rainbows.scm

@@ -0,0 +1,60 @@
+[
+  ; {/}
+  (declaration_list)
+  (field_declaration_list)
+  (field_initializer_list)
+  (enum_variant_list)
+  (block)
+  (match_block)
+  (use_list)
+  (struct_pattern)
+
+  ; (/)
+  (ordered_field_declaration_list)
+  (arguments)
+  (parameters)
+  (tuple_type)
+  (tuple_expression)
+  (tuple_pattern)
+  (tuple_struct_pattern)
+  (unit_type)
+  (unit_expression)
+  (visibility_modifier)
+  (parenthesized_expression)
+  (token_repetition_pattern)
+
+  ; </>
+  (type_parameters)
+  (type_arguments)
+  (bracketed_type)
+  (for_lifetimes)
+
+  ; [/]
+  (array_type)
+  (array_expression)
+  (index_expression)
+  (slice_pattern)
+
+  ; attributes #[]
+  (attribute_item)
+  (inner_attribute_item)
+
+  ; macros
+  (token_tree_pattern)
+  (macro_definition)
+
+  ; closures
+  (closure_parameters)
+] @rainbow.scope
+
+; attributes like `#[serde(rename_all = "kebab-case")]`
+(attribute arguments: (token_tree) @rainbow.scope)
+
+[
+  "#"
+  "[" "]"
+  "(" ")"
+  "{" "}"
+  "<" ">"
+  "|"
+] @rainbow.bracket

package/assets/queries/rust/tags.scm

@@ -0,0 +1,26 @@
+(struct_item
+  name: (type_identifier) @definition.struct)
+
+(const_item
+  name: (identifier) @definition.constant)
+
+(trait_item
+  name: (type_identifier) @definition.interface)
+
+(function_item
+  name: (identifier) @definition.function)
+
+(function_signature_item
+  name: (identifier) @definition.function)
+
+(enum_item
+  name: (type_identifier) @definition.type)
+
+(enum_variant
+  name: (identifier) @definition.struct)
+
+(mod_item
+  name: (identifier) @definition.module)
+
+(macro_definition
+  name: (identifier) @definition.macro)

package/assets/queries/rust/textobjects.scm

@@ -0,0 +1,85 @@
+(function_item
+  body: (_) @function.inside) @function.around
+
+(closure_expression
+  body: (_) @function.inside) @function.around
+
+(struct_item
+  body: (_) @class.inside) @class.around
+
+(enum_item
+  body: (_) @class.inside) @class.around
+
+(union_item
+  body: (_) @class.inside) @class.around
+
+(trait_item
+  body: (_) @class.inside) @class.around
+
+(impl_item
+  body: (_) @class.inside) @class.around
+
+(parameters 
+  ((_) @parameter.inside . ","? @parameter.around) @parameter.around)
+
+(type_parameters
+  ((_) @parameter.inside . ","? @parameter.around) @parameter.around)
+
+(type_arguments
+  ((_) @parameter.inside . ","? @parameter.around) @parameter.around)
+
+(closure_parameters
+  ((_) @parameter.inside . ","? @parameter.around) @parameter.around)
+
+(arguments
+  ((_) @parameter.inside . ","? @parameter.around) @parameter.around)
+
+(field_initializer_list  
+  ((_) @parameter.inside . ","? @parameter.around) @parameter.around)
+
+[
+  (line_comment)
+  (block_comment)
+] @comment.inside
+
+(line_comment)+ @comment.around
+
+(block_comment) @comment.around
+
+(; #[test]
+ (attribute_item
+   (attribute
+     (identifier) @_test_attribute))
+ ; allow other attributes like #[should_panic] and comments
+ [
+   (attribute_item)
+   (line_comment)
+ ]*
+ ; the test function
+ (function_item
+   body: (_) @test.inside) @test.around
+ (#eq? @_test_attribute "test"))
+
+(array_expression
+  (_) @entry.around)
+
+(tuple_expression
+  (_) @entry.around)
+
+(tuple_pattern
+  (_) @entry.around)
+
+; Commonly used vec macro initializer is special cased
+(macro_invocation
+  (identifier) @_id (token_tree (_) @entry.around)
+  (#eq? @_id "vec"))
+
+(enum_variant) @entry.around
+
+(field_declaration
+  (_) @entry.inside) @entry.around
+
+(field_initializer
+  (_) @entry.inside) @entry.around
+
+(shorthand_field_initializer) @entry.around

package/assets/queries/scala/highlights.scm

@@ -0,0 +1,267 @@
+; CREDITS @stumash (stuart.mashaal@gmail.com)
+
+;; variables
+
+(identifier) @variable
+
+(operator_identifier) @operator
+
+((identifier) @variable.builtin
+ (#match? @variable.builtin "^this$"))
+
+(interpolation) @none
+
+; Assume other uppercase names constants.
+; NOTE: In order to distinguish constants we highlight
+; all the identifiers that are uppercased. But this solution
+; is not suitable for all occurrences e.g. it will highlight
+; an uppercased method as a constant if used with no params.
+; Introducing highlighting for those specific cases, is probably
+; best way to resolve the issue.
+((identifier) @constant (#match? @constant "^[A-Z]"))
+
+;; types
+
+(type_identifier) @type
+
+(class_definition
+  name: (identifier) @type)
+
+(object_definition
+  name: (identifier) @type)
+
+(trait_definition
+  name: (identifier) @type)
+
+(type_definition
+  name: (type_identifier) @type)
+
+(full_enum_case
+  name: (identifier) @type)
+
+(simple_enum_case
+  name: (identifier) @type)
+
+;; val/var definitions/declarations
+
+(val_definition
+  pattern: (identifier) @variable)
+
+(var_definition
+  pattern: (identifier) @variable)
+
+(val_declaration
+  name: (identifier) @variable)
+
+(var_declaration
+  name: (identifier) @variable)
+
+; function definitions/declarations
+
+(function_declaration
+    name: (identifier) @function.method)
+
+(function_definition
+      name: (identifier) @function.method)
+
+; 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_expression
+  function: (operator_identifier) @function)
+
+(call_expression
+  function: (field_expression
+    field: (identifier) @function.method))
+
+(call_expression
+  function: (field_expression
+    field: (operator_identifier) @function.method))
+
+((call_expression
+   function: (identifier) @variable.other.member)
+ (#match? @variable.other.member "^[A-Z]"))
+
+(generic_function
+  function: (identifier) @function)
+
+(interpolated_string_expression
+  interpolator: (identifier) @function)
+
+(
+  (identifier) @function.builtin
+  (#match? @function.builtin "^super$")
+)
+
+; function definitions
+
+(function_definition
+  name: (identifier) @function)
+
+(function_definition
+  name: (operator_identifier) @function)
+
+(parameter
+  name: (identifier) @variable.parameter)
+
+(binding
+  name: (identifier) @variable.parameter)
+
+; expressions
+
+
+(field_expression field: (identifier) @variable.other.member)
+(field_expression value: (identifier) @type
+ (#match? @type "^[A-Z]"))
+
+(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) @constant.builtin.boolean
+(integer_literal) @constant.numeric.integer
+(floating_point_literal) @constant.numeric.float
+
+
+(symbol_literal) @string.special.symbol
+
+[
+(string)
+(character_literal)
+(interpolated_string_expression)
+] @string
+
+(interpolation "$" @punctuation.special)
+
+; annotations
+
+(annotation) @attribute
+
+;; keywords
+
+;; storage in TextMate scope lingo means field or type
+[
+  (opaque_modifier)
+  (infix_modifier)
+  (transparent_modifier)
+  (open_modifier)
+  "abstract"
+  "final"
+  "implicit"
+  "lazy"
+  "override"
+  "private"
+  "protected"
+  "sealed"
+] @keyword.storage.modifier
+
+[
+  "class"
+  "enum"
+  "extension"
+  "given"
+  "object"
+  "package"
+  "trait"
+  "type"
+  "val"
+  "var"
+] @keyword.storage.type
+
+[
+  "as"
+  "derives"
+  "end"
+  "extends"
+;; `forSome` existential types not implemented yet
+;; `macro` not implemented yet
+;; `throws`
+  "using"
+  "with"
+] @keyword
+
+(null_literal) @constant.builtin
+(wildcard) @keyword
+
+;; special keywords
+
+"new" @keyword.operator
+
+[
+  "case"
+  "catch"
+  "else"
+  "finally"
+  "if"
+  "match"
+  "then"
+  "throw"
+  "try"
+] @keyword.control.conditional
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "."
+  ","
+] @punctuation.delimiter
+
+[
+  "do"
+  "for"
+  "while"
+  "yield"
+] @keyword.control.repeat
+
+"def" @keyword.function
+
+[
+  "=>"
+  "<-"
+  "@"
+] @keyword.operator
+
+"import" @keyword.control.import
+
+"export" @keyword.control.import
+
+"return" @keyword.control.return
+
+[(comment) (block_comment)] @comment
+
+;; `case` is a conditional keyword in case_block
+
+(case_block
+  (case_clause ("case") @keyword.control.conditional))

package/assets/queries/scala/indents.scm

@@ -0,0 +1,22 @@
+[
+  (block)
+  (arguments)
+  (parameter)
+  (class_definition)
+  (trait_definition)
+  (object_definition)
+  (function_definition)
+  (val_definition)
+  (import_declaration)
+  (while_expression)
+  (do_while_expression)
+  (for_expression)
+  (try_expression)
+  (match_expression)
+] @indent
+
+[
+  "}"
+  "]"
+  ")"
+] @outdent

package/assets/queries/scala/injections.scm

@@ -0,0 +1,16 @@
+([(comment) (block_comment)] @injection.content
+ (#set! injection.language "comment"))
+
+
+; TODO for some reason multiline string (triple quotes) interpolation works only if it contains interpolated value
+; Matches these SQL interpolators:
+;  - Doobie: 'sql', 'fr'
+;  - Quill: 'sql', 'infix'
+;  - Slick: 'sql', 'sqlu'
+(interpolated_string_expression 
+  interpolator: 
+    ((identifier) @interpolator 
+     (#any-of? @interpolator "fr" "infix" "sql" "sqlu"))
+  (interpolated_string) @injection.content
+  (#set! injection.language "sql"))
+

package/assets/queries/scala/locals.scm

@@ -0,0 +1,14 @@
+(template_body) @local.scope
+(lambda_expression) @local.scope
+
+
+(function_declaration
+      name: (identifier) @local.definition.function) @local.scope
+
+(function_definition
+      name: (identifier) @local.definition.function)
+
+(parameter
+  name: (identifier) @local.definition.variable.parameter)
+
+(identifier) @local.reference