src-mcp 1.0.1

package/assets/queries/ecma/rainbows.scm

@@ -0,0 +1,28 @@
+[
+  (export_clause)
+  (named_imports)
+  (statement_block)
+  (for_statement)
+  (for_in_statement)
+  (switch_body)
+  (catch_clause "(" ")")
+  (parenthesized_expression)
+  (object)
+  (object_pattern)
+  (array)
+  (array_pattern)
+  (subscript_expression)
+  (template_substitution)
+  (arguments)
+  (class_body)
+  (formal_parameters)
+  (computed_property_name)
+] @rainbow.scope
+
+[
+  "(" ")"
+  "${" "{" "}"
+  "[" "]"
+] @rainbow.bracket
+
+(regex "/" @rainbow.bracket) @rainbow.scope

package/assets/queries/ecma/textobjects.scm

@@ -0,0 +1,45 @@
+(function_declaration
+  body: (_) @function.inside) @function.around
+
+(function_expression
+  body: (_) @function.inside) @function.around
+
+(arrow_function
+  body: (_) @function.inside) @function.around
+
+(method_definition
+  body: (_) @function.inside) @function.around
+
+(generator_function_declaration
+  body: (_) @function.inside) @function.around
+
+(class_declaration
+  body: (class_body) @class.inside) @class.around
+
+(class
+  (class_body) @class.inside) @class.around
+
+(export_statement
+  declaration: [
+    (function_declaration) @function.around
+    (class_declaration) @class.around 
+  ])
+
+(formal_parameters
+  ((_) @parameter.inside . ","? @parameter.around) @parameter.around)
+
+(arguments
+  ((_) @parameter.inside . ","? @parameter.around) @parameter.around)
+
+(comment) @comment.inside
+
+(comment)+ @comment.around
+
+(array 
+  (_) @entry.around)
+
+(pair
+  (_) @entry.inside) @entry.around
+
+(pair_pattern
+  (_) @entry.inside) @entry.around

package/assets/queries/go/highlights.scm

@@ -0,0 +1,236 @@
+
+; Identifiers
+
+(field_identifier) @variable.other.member
+
+(identifier) @variable
+
+(package_identifier) @namespace
+
+(const_spec
+  name: (identifier) @constant)
+
+(type_spec
+  name: (type_identifier) @constructor)
+
+(keyed_element . (literal_element (identifier) @variable.other.member))
+(field_declaration
+  name: (field_identifier) @variable.other.member)
+
+(parameter_declaration (identifier) @variable.parameter)
+(variadic_parameter_declaration (identifier) @variable.parameter)
+
+(label_name) @label
+
+(const_spec
+  name: (identifier) @constant)
+
+; Function calls
+
+(call_expression
+  function: (identifier) @function)
+
+(call_expression
+  function: (selector_expression
+    field: (field_identifier) @function.method))
+
+(call_expression
+  function: (identifier) @function.builtin
+  (#match? @function.builtin "^(append|cap|close|complex|copy|delete|imag|len|make|new|panic|print|println|real|recover|min|max|clear)$"))
+
+; Types
+
+(type_identifier) @type
+
+(type_parameter_list
+  (type_parameter_declaration
+    name: (identifier) @type.parameter))
+
+((type_identifier) @type.builtin
+  (#match? @type.builtin "^(any|bool|byte|comparable|complex128|complex64|error|float32|float64|int|int16|int32|int64|int8|rune|string|uint|uint16|uint32|uint64|uint8|uintptr)$"))
+
+; Function definitions
+
+(function_declaration
+  name: (identifier) @function)
+
+(method_declaration
+  name: (field_identifier) @function.method)
+
+(method_elem
+  name: (field_identifier) @function.method)
+
+; Operators
+
+[
+  "--"
+  "-"
+  "-="
+  ":="
+  "!"
+  "!="
+  "..."
+  "*"
+  "*"
+  "*="
+  "/"
+  "/="
+  "&"
+  "&&"
+  "&="
+  "%"
+  "%="
+  "^"
+  "^="
+  "+"
+  "++"
+  "+="
+  "<-"
+  "<"
+  "<<"
+  "<<="
+  "<="
+  "="
+  "=="
+  ">"
+  ">="
+  ">>"
+  ">>="
+  "|"
+  "|="
+  "||"
+  "&^"
+  "&^="
+  "~"
+] @operator
+
+; Keywords
+
+[
+  "default"
+  "type"
+] @keyword
+
+[
+  "defer"
+  "go"
+  "goto"
+] @keyword.control
+
+[
+  "if"
+  "else"
+  "switch"
+  "select"
+  "case"
+] @keyword.control.conditional
+
+[
+  "for"
+  "range"
+] @keyword.control.repeat
+
+[
+  "import"
+  "package"
+] @keyword.control.import
+
+[
+  "return"
+  "continue"
+  "break"
+  "fallthrough"
+] @keyword.control.return
+
+[
+  "func"
+] @keyword.function
+
+[
+  "var"
+  "chan"
+  "interface"
+  "map"
+  "struct"
+] @keyword.storage.type
+
+[
+  "const"
+] @keyword.storage.modifier
+
+; Delimiters
+
+[
+  ":"
+  "."
+  ","
+  ";"
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+; Literals
+
+[
+  (interpreted_string_literal)
+  (raw_string_literal)
+] @string
+
+(rune_literal) @constant.character
+
+(escape_sequence) @constant.character.escape
+
+[
+  (int_literal)
+] @constant.numeric.integer
+
+[
+  (float_literal)
+  (imaginary_literal)
+] @constant.numeric.float
+
+[
+  (true)
+  (false)
+] @constant.builtin.boolean
+
+[
+  (nil)
+  (iota)
+] @constant.builtin
+
+; Comments
+
+(comment) @comment
+
+; Doc Comments
+(source_file
+  .
+  (comment)+ @comment.block.documentation)
+
+(source_file
+  (comment)+ @comment.block.documentation
+  .
+  (const_declaration))
+
+(source_file
+  (comment)+ @comment.block.documentation
+  .
+  (function_declaration))
+
+(source_file
+  (comment)+ @comment.block.documentation
+  .
+  (type_declaration))
+
+(source_file
+  (comment)+ @comment.block.documentation
+  .
+  (var_declaration))

package/assets/queries/go/indents.scm

@@ -0,0 +1,40 @@
+[
+  (import_declaration)
+  (const_declaration)
+  (type_declaration)
+  (type_spec)
+  (func_literal)
+  (literal_value)
+  (literal_element)
+  (keyed_element)
+  (expression_case)
+  (default_case)
+  (type_case)
+  (communication_case)
+  (argument_list)
+  (field_declaration_list)
+  (block)
+  (var_declaration)
+] @indent
+
+[
+  "]"
+  ")"
+] @outdent
+
+; Switches and selects aren't indented, only their case bodies are.
+; Outdent all closing braces except those closing switches or selects.
+(
+    (_ "}" @outdent) @outer
+    (#not-kind-eq? @outer "select_statement")
+    (#not-kind-eq? @outer "type_switch_statement")
+    (#not-kind-eq? @outer "expression_switch_statement")
+)
+
+; Starting a line after a new case should indent.
+[
+  (communication_case)
+  (expression_case)
+  (default_case)
+  (type_case)
+] @extend

package/assets/queries/go/injections.scm

@@ -0,0 +1,92 @@
+((comment) @injection.content
+ (#set! injection.language "comment"))
+
+; Inject markdown into documentation comments
+;
+; Go's comments are documentation comments when they are directly followed
+; by one of Go's statements (e.g. `type`, `func`, `const`)
+;
+; This is only a partial implementation, which covers only
+; block comments. For line comments (which are more common),
+; upstream changes to the grammar are required.
+(
+  (comment) @injection.content . (comment)* . [
+    (package_clause) ; `package`
+    (type_declaration) ; `type`
+    (function_declaration) ; `func`
+    (method_declaration) ; `func`
+    (var_declaration) ; `var`
+    (const_declaration) ; `const`
+    ; var (
+    ; 	A = 1
+    ; 	B = 2
+    ; )
+    (const_spec)
+    ; const (
+    ; 	A = 1
+    ; 	B = 2
+    ; )
+    (var_spec)
+  ]
+  (#set! injection.language "markdown"))
+
+((comment) @injection.content
+ (#match? @injection.content "^//go:generate")
+ (#set! injection.language "bash"))
+
+(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)
+      (interpreted_string_literal)
+    ] @injection.content
+    (#set! injection.language "regex")))
+
+; https://pkg.go.dev/fmt#Printf
+; https://pkg.go.dev/fmt#Sprintf
+; https://pkg.go.dev/fmt#Scanf
+; https://pkg.go.dev/fmt#Errorf
+((call_expression
+  function: (selector_expression
+    operand: (identifier) @_module
+    field: (field_identifier) @_func)
+  arguments: (argument_list
+    . (interpreted_string_literal) @injection.content))
+  (#eq? @_module "fmt")
+  (#any-of? @_func "Printf" "Sprintf" "Scanf" "Errorf")
+  (#set! injection.language "go-format-string"))
+
+; https://pkg.go.dev/fmt#Fprintf
+; https://pkg.go.dev/fmt#Fscanf
+; https://pkg.go.dev/fmt#Sscanf
+((call_expression
+  function: (selector_expression
+    operand: (identifier) @_module
+    field: (field_identifier) @_func)
+  arguments: (argument_list
+    ; [(identifier) (interpreted_string_literal)]
+    (_)
+    ; (identifier)
+    .
+    (interpreted_string_literal) @injection.content))
+  (#eq? @_module "fmt")
+  (#any-of? @_func "Fprintf" "Fscanf" "Sscanf")
+  (#set! injection.language "go-format-string"))
+
+; https://pkg.go.dev/log#Printf
+; https://pkg.go.dev/log#Fatalf
+; https://pkg.go.dev/log#Panicf
+; https://pkg.go.dev/log#Logger.Printf
+; https://pkg.go.dev/log#Logger.Fatalf
+; https://pkg.go.dev/log#Logger.Panicf
+((call_expression
+  function: (selector_expression
+    operand: (identifier)
+    field: (field_identifier) @_func)
+  arguments: (argument_list
+    . (interpreted_string_literal) @injection.content))
+  (#any-of? @_func "Printf" "Fatalf" "Panicf")
+  (#set! injection.language "go-format-string"))

package/assets/queries/go/locals.scm

@@ -0,0 +1,25 @@
+; Scopes
+
+[
+  (function_declaration)
+  (method_declaration)
+  (type_declaration)
+  (block)
+] @local.scope
+
+; Definitions
+
+(parameter_declaration (identifier) @local.definition.variable.parameter)
+(variadic_parameter_declaration (identifier) @local.definition.variable.parameter)
+
+(const_declaration
+ (const_spec
+  name: (identifier) @local.definition.constant))
+
+; References
+
+(identifier) @local.reference
+
+; Field names in struct literals are identifier rather than field_identifier,
+; these cannot be locals.
+(keyed_element . (literal_element (identifier) @variable.other.member))

package/assets/queries/go/rainbows.scm

@@ -0,0 +1,33 @@
+[
+  (import_spec_list)
+  (const_declaration)
+  (var_declaration)
+  (type_parameter_list)
+  (parameter_list)
+  (type_declaration)
+  (parenthesized_type)
+  (type_arguments)
+  (array_type)
+  (implicit_length_array_type)
+  (slice_type)
+  (field_declaration_list)
+  (interface_type)
+  (map_type)
+  (block)
+  (expression_switch_statement)
+  (type_switch_statement)
+  (select_statement)
+  (parenthesized_expression)
+  (argument_list)
+  (index_expression)
+  (slice_expression)
+  (type_assertion_expression)
+  (type_conversion_expression)
+  (literal_value)
+] @rainbow.scope
+
+[
+  "(" ")"
+  "[" "]"
+  "{" "}"
+] @rainbow.bracket

package/assets/queries/go/tags.scm

@@ -0,0 +1,30 @@
+(
+  (comment)* @doc
+  .
+  (function_declaration
+    name: (identifier) @name) @definition.function
+  (#strip! @doc "^//\\s*")
+  (#select-adjacent! @doc @definition.function)
+)
+
+(
+  (comment)* @doc
+  .
+  (method_declaration
+    name: (field_identifier) @name) @definition.method
+  (#strip! @doc "^//\\s*")
+  (#select-adjacent! @doc @definition.method)
+)
+
+(call_expression
+  function: [
+    (identifier) @name
+    (parenthesized_expression (identifier) @name)
+    (selector_expression field: (field_identifier) @name)
+    (parenthesized_expression (selector_expression field: (field_identifier) @name))
+  ]) @reference.call
+
+(type_spec
+  name: (type_identifier) @name) @definition.type
+
+(type_identifier) @name @reference.type

package/assets/queries/go/textobjects.scm

@@ -0,0 +1,33 @@
+(function_declaration
+  body: (block)? @function.inside) @function.around
+
+(func_literal
+  (_)? @function.inside) @function.around
+
+(method_declaration
+  body: (block)? @function.inside) @function.around
+
+;; struct and interface declaration as class textobject?
+(type_declaration
+  (type_spec (type_identifier) (struct_type (field_declaration_list (_)?) @class.inside))) @class.around
+
+(type_declaration
+  (type_spec (type_identifier) (interface_type (method_elem)+ @class.inside))) @class.around
+
+(type_parameter_list
+  ((_) @parameter.inside . ","? @parameter.around) @parameter.around)
+
+(parameter_list
+  ((_) @parameter.inside . ","? @parameter.around) @parameter.around)
+
+(argument_list
+  ((_) @parameter.inside . ","? @parameter.around) @parameter.around)
+
+(comment) @comment.inside
+
+(comment)+ @comment.around
+
+((function_declaration
+   name: (identifier) @_name
+   body: (block)? @test.inside) @test.around
+ (#match? @_name "^Test"))

package/assets/queries/html/highlights.scm

@@ -0,0 +1,47 @@
+(tag_name) @tag
+(erroneous_end_tag_name) @error
+(doctype) @constant
+(attribute_name) @attribute
+(entity) @string.special.symbol
+(comment) @comment
+
+((attribute
+  (attribute_name) @attribute
+  (quoted_attribute_value (attribute_value) @markup.link.url))
+ (#any-of? @attribute "href" "src"))
+
+((element
+  (start_tag
+    (tag_name) @tag)
+  (text) @markup.link.label)
+  (#eq? @tag "a"))
+
+(attribute [(attribute_value) (quoted_attribute_value)] @string)
+
+((element
+  (start_tag
+    (tag_name) @tag)
+  (text) @markup.bold)
+  (#any-of? @tag "strong" "b"))
+
+((element
+  (start_tag
+    (tag_name) @tag)
+  (text) @markup.italic)
+  (#any-of? @tag "em" "i"))
+
+((element
+  (start_tag
+    (tag_name) @tag)
+  (text) @markup.strikethrough)
+  (#any-of? @tag "s" "del"))
+
+[
+  "<"
+  ">"
+  "</"
+  "/>"
+  "<!"
+] @punctuation.bracket
+
+"=" @punctuation.delimiter

package/assets/queries/html/injections.scm

@@ -0,0 +1,10 @@
+((comment) @injection.content
+ (#set! injection.language "comment"))
+
+((script_element
+  (raw_text) @injection.content)
+ (#set! injection.language "javascript"))
+
+((style_element
+  (raw_text) @injection.content)
+ (#set! injection.language "css"))

package/assets/queries/html/rainbows.scm

@@ -0,0 +1,13 @@
+[
+  (doctype)
+  (erroneous_end_tag)
+] @rainbow.scope
+
+([
+   (element)
+   (script_element)
+   (style_element)
+ ] @rainbow.scope
+ (#set! rainbow.include-children))
+
+["<" ">" "<!" "</" "/>"] @rainbow.bracket

package/assets/queries/html/textobjects.scm

@@ -0,0 +1,9 @@
+(script_element (start_tag) (_) @xml-element.inside (end_tag))  @xml-element.around
+
+(style_element (start_tag) (_) @xml-element.inside (end_tag)) @xml-element.around
+
+(element (start_tag) (_)* @xml-element.inside (end_tag))
+
+(element) @xml-element.around
+
+(comment) @comment.around