src-mcp 1.0.1

package/assets/queries/kotlin/highlights.scm

@@ -0,0 +1,330 @@
+;;; Identifiers
+(simple_identifier) @variable
+
+; `field` keyword inside property getter/setter
+; FIXME: This will highlight the keyword outside of getters and setters
+;        since tree-sitter does not allow us to check for arbitrary nestation
+((simple_identifier) @variable.builtin
+(#eq? @variable.builtin "field"))
+
+; `it` keyword inside lambdas
+; FIXME: This will highlight the keyword outside of lambdas since tree-sitter
+;        does not allow us to check for arbitrary nestation
+((simple_identifier) @variable.builtin
+(#eq? @variable.builtin "it"))
+
+
+;;; Operators & Punctuation
+
+[
+	"."
+	","
+	";"
+	":"
+	"::"
+] @punctuation.delimiter
+
+[
+	"(" ")"
+	"[" "]"
+	"{" "}"
+] @punctuation.bracket
+
+[
+	"!"
+	"!="
+	"!=="
+	"="
+	"=="
+	"==="
+	">"
+	">="
+	"<"
+	"<="
+	"||"
+	"&&"
+	"+"
+	"++"
+	"+="
+	"-"
+	"--"
+	"-="
+	"*"
+	"*="
+	"/"
+	"/="
+	"%"
+	"%="
+	"?."
+	"?:"
+	"!!"
+	"is"
+	"!is"
+	"in"
+	"!in"
+	"as"
+	"as?"
+	".."
+	"->"
+] @operator
+
+;;; String interpolation
+
+(string_literal
+	"$" @punctuation.special
+  (interpolated_identifier) @variable)
+(string_literal
+	"${" @punctuation.special
+	(interpolated_expression) @none
+	"}" @punctuation.special)
+
+; `it` and `this` inside string interpolation
+((interpolated_identifier) @variable.builtin
+(#eq? @variable.builtin "it"))
+((interpolated_identifier) @variable.builtin
+(#eq? @variable.builtin "this"))
+
+;;; Keywords
+
+(type_alias "typealias" @keyword)
+[
+	(class_modifier)
+	(member_modifier)
+	(function_modifier)
+	(property_modifier)
+	(platform_modifier)
+	(variance_modifier)
+	(parameter_modifier)
+	(visibility_modifier)
+	(reification_modifier)
+	(inheritance_modifier)
+]@keyword
+
+[
+	"val"
+	"var"
+	"enum"
+	"class"
+	"object"
+	"interface"
+	"companion"
+;	"typeof" ; NOTE: It is reserved for future use
+] @keyword
+
+("fun") @keyword.function
+
+(jump_expression) @keyword.control.return
+
+[
+	"if"
+	"else"
+	"when"
+] @keyword.control.conditional
+
+[
+	"for"
+	"do"
+	"while"
+] @keyword.control.repeat
+
+[
+	"try"
+	"catch"
+	"throw"
+	"finally"
+] @keyword.control.exception
+
+(annotation
+	"@" @attribute (use_site_target)? @attribute)
+(annotation
+	(user_type
+		(type_identifier) @attribute))
+(annotation
+	(constructor_invocation
+		(user_type
+			(type_identifier) @attribute)))
+
+(file_annotation
+	"@" @attribute "file" @attribute ":" @attribute)
+(file_annotation
+	(user_type
+		(type_identifier) @attribute))
+(file_annotation
+	(constructor_invocation
+		(user_type
+			(type_identifier) @attribute)))
+
+;;; Literals
+; NOTE: Escapes not allowed in multi-line strings
+(character_literal (character_escape_seq) @constant.character.escape)
+
+(string_literal) @string
+
+(character_literal) @constant.character
+
+[
+	(null_literal) ; should be highlighted the same as booleans
+	(boolean_literal)
+] @constant.builtin.boolean
+
+(real_literal) @constant.numeric.float
+[
+	(integer_literal)
+	(long_literal)
+	(hex_literal)
+	(bin_literal)
+	(unsigned_literal)
+] @constant.numeric.integer
+
+[
+	(line_comment)
+	(multiline_comment)
+	(shebang_line)
+] @comment
+
+;;; Constants
+
+(enum_entry
+	(simple_identifier) @constant)
+
+; SCREAMING CASE identifiers are assumed to be constants
+((simple_identifier) @constant
+(#match? @constant "^[A-Z][A-Z0-9_]*$"))
+
+;;; Navigation, Members & Function calls
+
+; generic property navigation (e.g. obj.property)
+(_
+	(navigation_suffix
+		(simple_identifier) @variable.other.member))
+
+; generic function call (e.g. foo())
+(call_expression
+	. (simple_identifier) @function)
+
+; method call via navigation (e.g. obj.method())
+(call_expression
+	(navigation_expression
+		(navigation_suffix
+			(simple_identifier) @function) . ))
+
+; infix function call (e.g. 1 to 2)
+(infix_expression
+  . (_) .
+	(simple_identifier) @function)
+
+; builtin function calls
+(call_expression
+	. (simple_identifier) @function.builtin
+    (#match? @function.builtin "^(arrayOf|arrayOfNulls|byteArrayOf|shortArrayOf|intArrayOf|longArrayOf|ubyteArrayOf|ushortArrayOf|uintArrayOf|ulongArrayOf|floatArrayOf|doubleArrayOf|booleanArrayOf|charArrayOf|emptyArray|mapOf|setOf|listOf|emptyMap|emptySet|emptyList|mutableMapOf|mutableSetOf|mutableListOf|print|println|error|TODO|run|runCatching|repeat|lazy|lazyOf|enumValues|enumValueOf|assert|check|checkNotNull|require|requireNotNull|with|suspend|synchronized)$"))
+
+; constant access via navigation (e.g. Foo.CONSTANT)
+(_
+	(navigation_suffix
+		(simple_identifier) @constant
+		(#match? @constant "^[A-Z][A-Z0-9_]*$")))
+
+; object or class reference (e.g. TextObjects.TEXT)
+((navigation_expression
+  . (simple_identifier) @type)
+  (#match? @type "^[A-Z]"))
+
+;;; Function definitions
+
+; lambda parameters
+(lambda_literal
+	(lambda_parameters
+		(variable_declaration
+			(simple_identifier) @variable.parameter)))
+			
+(parameter_with_optional_type
+	(simple_identifier) @variable.parameter)
+			
+(parameter
+	(simple_identifier) @variable.parameter)
+
+; named arguments
+(value_argument
+  . (simple_identifier) @variable.parameter)
+
+(anonymous_initializer
+	("init") @constructor)
+
+(constructor_invocation
+	(user_type
+		(type_identifier) @constructor))
+			
+(secondary_constructor
+	("constructor") @constructor)
+(primary_constructor) @constructor
+			
+(getter
+	("get") @function.builtin)
+(setter
+	("set") @function.builtin)
+
+; normal function
+(function_declaration
+	(modifiers)?
+	(type_parameters)?
+	(simple_identifier) @function)
+
+; extension function
+(function_declaration
+	receiver: (receiver_type)
+	(simple_identifier) @function)
+
+; TODO: Separate labeled returns/breaks/continue/super/this
+;       Must be implemented in the parser first
+(label) @label
+
+(import_header
+	(identifier
+		(simple_identifier) @function @_import .)
+	(import_alias
+		(type_identifier) @function)?
+		(#match? @_import "^[a-z]"))
+
+; The last `simple_identifier` in a `import_header` will always either be a function
+; or a type. Classes can appear anywhere in the import path, unlike functions
+(import_header
+	(identifier
+		(simple_identifier) @type @_import)
+	(import_alias
+		(type_identifier) @type)?
+		(#match? @_import "^[A-Z]"))
+
+(import_header
+	"import" @keyword.control.import)
+
+(package_header
+	. (identifier)) @namespace
+
+(type_identifier) @type
+
+((type_identifier) @type.builtin
+	(#match? @type.builtin "^(Byte|Short|Int|Long|UByte|UShort|UInt|ULong|Float|Double|Boolean|Char|String|Array|ByteArray|ShortArray|IntArray|LongArray|UByteArray|UShortArray|UIntArray|ULongArray|FloatArray|DoubleArray|BooleanArray|CharArray|Map|Set|List|EmptyMap|EmptySet|EmptyList|MutableMap|MutableSet|MutableList)$"))
+
+(type_parameter
+  (type_identifier) @type.parameter)
+
+((class_body
+	(property_declaration
+		(variable_declaration
+			(simple_identifier) @variable.other.member)))
+  (#not-match? @variable.other.member "^[A-Z][A-Z0-9_]*$"))
+
+; Extension property
+(property_declaration
+  receiver: (receiver_type)
+  (variable_declaration
+    (simple_identifier) @variable.other.member))
+
+(class_parameter
+	(simple_identifier) @variable.other.member)
+
+; `super` keyword inside classes
+(super_expression) @variable.builtin
+
+; `this` this keyword inside classes
+(this_expression) @variable.builtin

package/assets/queries/kotlin/indents.scm

@@ -0,0 +1,44 @@
+[
+  (class_body)
+  (enum_class_body)
+  (lambda_literal)
+
+  ; _block is hidden in the grammar, so list all public wrappers explicitly.
+  (function_body)
+  (anonymous_initializer)
+  (control_structure_body)
+  (secondary_constructor)
+  (try_expression)
+  (catch_block)
+  (finally_block)
+
+  (property_declaration)
+  (assignment)
+
+  (when_expression)
+  (call_expression)
+  (if_expression)
+
+  ; Binary expressions
+  (multiplicative_expression)
+  (additive_expression)
+  (range_expression)
+  (infix_expression)
+  (elvis_expression)
+  (check_expression)
+  (comparison_expression)
+  (equality_expression)
+  (comparison_expression)
+  (equality_expression)
+  (conjunction_expression)
+  (disjunction_expression)
+
+  (call_suffix)
+  (function_value_parameters)
+] @indent
+
+[
+  "}"
+  ")"
+  "]"
+] @outdent

package/assets/queries/kotlin/injections.scm

@@ -0,0 +1,42 @@
+([
+  (line_comment)
+  (multiline_comment)
+ ] @injection.content
+	(#set! injection.language "comment"))
+
+; There are 3 ways to define a regex
+;    - "[abc]?".toRegex()
+((call_expression
+	(navigation_expression
+		(string_literal
+		   (string_content) @injection.content)
+		(navigation_suffix
+			((simple_identifier) @_function
+			(#eq? @_function "toRegex")))))
+	(#set! injection.language "regex"))
+
+;    - Regex("[abc]?")
+((call_expression
+	((simple_identifier) @_function
+	(#eq? @_function "Regex"))
+	(call_suffix
+		(value_arguments
+			(value_argument
+				(string_literal
+					(string_content) @injection.content)))))
+	(#set! injection.language "regex"))
+
+;    - Regex.fromLiteral("[abc]?")
+((call_expression
+	(navigation_expression
+		((simple_identifier) @_class
+		(#eq? @_class "Regex"))
+		(navigation_suffix
+			((simple_identifier) @_function
+			(#eq? @_function "fromLiteral"))))
+	(call_suffix
+		(value_arguments
+			(value_argument
+				(string_literal
+					(string_content) @injection.content)))))
+	(#set! injection.language "regex"))

package/assets/queries/kotlin/locals.scm

@@ -0,0 +1,23 @@
+; Scopes
+[
+  (class_declaration)
+  (function_declaration)
+  (lambda_literal)
+] @local.scope
+
+; Definitions
+(type_parameter
+  (type_identifier) @local.definition.type.parameter)
+
+(parameter
+  (simple_identifier) @local.definition.variable.parameter)
+
+(lambda_literal
+  (lambda_parameters
+    (variable_declaration
+      (simple_identifier) @local.definition.variable.parameter)))
+
+; References
+(simple_identifier) @local.reference
+(type_identifier) @local.reference
+(interpolated_identifier) @local.reference

package/assets/queries/kotlin/tags.scm

@@ -0,0 +1,12 @@
+(class_declaration
+  (type_identifier) @definition.class)
+
+(object_declaration
+  "object" (type_identifier) @definition.class)
+
+(function_declaration
+  (simple_identifier) @definition.function)
+
+(property_declaration
+  (variable_declaration
+    (simple_identifier) @definition.constant))

package/assets/queries/kotlin/textobjects.scm

@@ -0,0 +1,45 @@
+(function_declaration
+  (function_body)? @function.inside) @function.around
+
+; Unlike function_body above, the constructor body is does not have its own
+; symbol in the current grammar.
+(secondary_constructor) @function.around
+
+(class_declaration
+  (class_body)? @class.inside) @class.around
+
+(class_declaration
+  (enum_class_body) @class.inside) @class.around
+
+[
+  (line_comment)
+  (multiline_comment)
+] @comment.inside
+
+(line_comment)+ @comment.around
+
+(multiline_comment) @comment.around
+
+(enum_entry) @entry.around
+(lambda_literal) @entry.around
+(property_declaration) @entry.around
+(object_declaration) @entry.around
+(assignment) @entry.around
+
+; TODO: This doesn't work with annotations yet, but fixing it without breaking
+; the case of multiple parameters is non-trivial.
+(function_value_parameters
+  ((_) @parameter.inside . ","? @parameter.around) @parameter.around)
+
+; secondary constructor uses function_value_parameters above
+(primary_constructor
+  ((_)@parameter.inside . ","? @parameter.around) @parameter.around)
+
+(function_type_parameters
+  ((_)@parameter.inside . ","? @parameter.around) @parameter.around)
+
+(value_arguments
+  ((_)@parameter.inside . ","? @parameter.around) @parameter.around)
+
+(lambda_parameters
+  ((_) @parameter.inside . ","? @parameter.around) @parameter.around)

package/assets/queries/ocaml/highlights.scm

@@ -0,0 +1,151 @@
+; Punctuation
+;------------
+
+"%" @punctuation.special
+
+["(" ")" "[" "]" "{" "}" "[|" "|]" "[<" "[>"] @punctuation.bracket
+
+[
+  "," "." ";" ":" "=" "|" "~" "?" "+" "-" "!" ">" "&"
+  "->" ";;" ":>" "+=" ":=" ".."
+] @punctuation.delimiter
+
+(object_type ["<" ">"] @punctuation.bracket)
+
+(attribute ["[@" "]"] @punctuation.special)
+(item_attribute ["[@@" "]"] @punctuation.special)
+(floating_attribute ["[@@@" "]"] @punctuation.special)
+(extension ["[%" "]"] @punctuation.special)
+(item_extension ["[%%" "]"] @punctuation.special)
+(quoted_extension ["{%" "}"] @punctuation.special)
+(quoted_item_extension ["{%%" "}"] @punctuation.special)
+
+; Modules
+;--------
+
+[(module_name) (module_type_name)] @namespace
+
+; Types
+;------
+
+(
+  (type_constructor) @type.builtin
+  (#match? @type.builtin "^(int|char|bytes|string|float|bool|unit|exn|array|list|option|int32|int64|nativeint|format6|lazy_t)$")
+)
+
+[(class_name) (class_type_name) (type_constructor)] @type
+
+[(constructor_name) (tag)] @constructor
+
+; Variables
+;----------
+
+[(value_name) (type_variable)] @variable
+
+(value_pattern) @variable.parameter
+
+; Functions
+;----------
+
+(let_binding
+  pattern: (value_name) @function
+  (parameter))
+
+(let_binding
+  pattern: (value_name) @function
+  body: [(fun_expression) (function_expression)])
+
+(value_specification (value_name) @function)
+
+(external (value_name) @function)
+
+(method_name) @function.method
+
+; Application
+;------------
+
+(
+  (value_name) @function.builtin
+  (#match? @function.builtin "^(raise(_notrace)?|failwith|invalid_arg)$")
+)
+
+(infix_expression
+  left: (value_path (value_name) @function)
+  operator: (concat_operator) @operator
+  (#eq? @operator "@@"))
+
+(infix_expression
+  operator: (rel_operator) @operator
+  right: (value_path (value_name) @function)
+  (#eq? @operator "|>"))
+
+(application_expression
+  function: (value_path (value_name) @function))
+
+; Properties
+;-----------
+
+[(label_name) (field_name) (instance_variable_name)] @variable.other.member
+
+; Constants
+;----------
+
+(boolean) @constant.builtin.boolean
+
+[(number) (signed_number)] @constant.numeric
+
+[(string) (character)] @string
+
+(quoted_string "{" @string "}" @string) @string
+
+(escape_sequence) @constant.character.escape
+
+(conversion_specification) @string.special
+
+; Operators
+;----------
+
+["*" "#" "::" "<-"] @operator
+
+[
+  (prefix_operator)
+  (sign_operator)
+  (pow_operator)
+  (mult_operator)
+  (add_operator)
+  (concat_operator)
+  (rel_operator)
+  (and_operator)
+  (or_operator)
+  (assign_operator)
+  (hash_operator)
+  (indexing_operator)
+  (let_operator)
+  (let_and_operator)
+  (match_operator)
+] @operator
+
+(match_expression (match_operator) @keyword)
+
+(value_definition [(let_operator) (let_and_operator)] @keyword)
+
+; Keywords
+;---------
+
+[
+  "and" "as" "assert" "begin" "class" "constraint" "do" "done" "downto" "else"
+  "end" "exception" "external" "for" "fun" "function" "functor" "if" "in"
+  "include" "inherit" "initializer" "lazy" "let" "match" "method" "module"
+  "mutable" "new" "nonrec" "object" "of" "open" "private" "rec" "sig" "struct"
+  "then" "to" "try" "type" "val" "virtual" "when" "while" "with"
+] @keyword
+
+; Attributes
+;-----------
+
+(attribute_id) @tag
+
+; Comments
+;---------
+
+[(comment) (line_number_directive) (directive) (shebang)] @comment

package/assets/queries/ocaml/indents.scm

@@ -0,0 +1,12 @@
+[
+  (let_binding)
+  (type_binding)
+  (structure)
+  (signature)
+  (record_declaration)
+  (function_expression)
+  (match_case)
+] @indent
+
+"}" @outdent
+

package/assets/queries/ocaml/injections.scm

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

package/assets/queries/ocaml/locals.scm

@@ -0,0 +1,24 @@
+; Scopes
+;-------
+
+[
+  (let_binding)
+  (class_binding)
+  (class_function)
+  (method_definition)
+  (fun_expression)
+  (object_expression)
+  (for_expression)
+  (match_case)
+  (attribute_payload)
+] @local.scope
+
+; Definitions
+;------------
+
+(value_pattern) @local.definition.variable.parameter
+
+; References
+;-----------
+
+(value_path . (value_name) @local.reference)