Unnamed repository; edit this file 'description' to name the repository.
Diffstat (limited to 'runtime/queries/nim/highlights.scm')
| -rw-r--r-- | runtime/queries/nim/highlights.scm | 528 |
1 files changed, 255 insertions, 273 deletions
diff --git a/runtime/queries/nim/highlights.scm b/runtime/queries/nim/highlights.scm index 791e8e02..1d325685 100644 --- a/runtime/queries/nim/highlights.scm +++ b/runtime/queries/nim/highlights.scm @@ -1,34 +1,33 @@ -(identifier) @variable - ;; Constants, Comments, and Literals (comment) @comment.line -(block_comment) @comment.block -[ - (documentation_comment) - (block_documentation_comment) -] @comment.block.documentation - -(nil_literal) @constant.builtin -((identifier) @constant.builtin.boolean - (#any-of? @constant.builtin.boolean "true" "false" "on" "off")) - -(char_literal) @constant.character -(escape_sequence) @constant.character.escape -(custom_numeric_literal) @constant.numeric -(integer_literal) @constant.numeric.integer -(float_literal) @constant.numeric.float +(multilineComment) @comment.block +(docComment) @comment.block.documentation +(multilineDocComment) @comment.block.documentation +; comments + +[(literal) (generalizedLit)] @constant +[(nil_lit)] @constant.builtin +[(bool_lit)] @constant.builtin.boolean +[(char_lit)] @constant.character +[(char_esc_seq) (str_esc_seq)] @constant.character.escape +[(custom_numeric_lit)] @constant.numeric +[(int_lit) (int_suffix)] @constant.numeric.integer +[(float_lit) (float_suffix)] @constant.numeric.float ; literals -; todo: literal? +; note: somewhat irritatingly for testing, lits have the same syntax highlighting as types [ - (long_string_literal) - (raw_string_literal) - (generalized_string) - (interpreted_string_literal) + (str_lit) + (triplestr_lit) + (rstr_lit) + (generalized_str_lit) + (generalized_triplestr_lit) + (interpolated_str_lit) + (interpolated_triplestr_lit) ] @string -; (generalized_string (string_content) @none) ; todo: attempt to un-match string_content ; [] @string.regexp +; string literals [ "." @@ -45,289 +44,272 @@ "}" "{." ".}" + "#[" + "]#" ] @punctuation.bracket -; todo: interpolated_str_lit?? & { }? +(interpolated_str_lit "&" @punctuation.special) +(interpolated_str_lit "{" @punctuation.special) +(interpolated_str_lit "}" @punctuation.special) +; punctuation [ "and" "or" "xor" "not" - "div" - "mod" - "shl" - "shr" - "from" - "as" - "of" "in" "notin" "is" "isnot" + "div" + "mod" + "shl" + "shr" ] @keyword.operator +; operators: we list them explicitly to deliminate them from symbolic operators + +[(operator) (opr) "="] @operator +; all operators (must come after @keyword.operator) -[(operator) "="] @operator -(infix_expression operator: _ @operator) -(prefix_expression operator: _ @operator) +(pragma) @attribute +; pragmas -(pragma_list - (identifier)? @attribute - (colon_expression - (identifier) @attribute)?) ;; Imports and Exports -[ - "import" - "export" - "include" - "from" -] @keyword.control.import - -(import_statement - [ - (identifier) @namespace - (expression_list (identifier) @namespace) - (except_clause - "except" @keyword.control.import - (expression_list (identifier) @namespace))]) -(import_from_statement - (identifier) @namespace - (expression_list (identifier) @namespace)) -(include_statement (expression_list (identifier) @namespace)) -(export_statement (expression_list (identifier) @namespace)) +(importStmt + (keyw) @keyword.control.import + (expr (primary (symbol) @namespace))? + (expr (primary (arrayConstr (exprColonExprList (exprColonExpr (expr (primary (symbol) @namespace)))))))?) +(exportStmt + (keyw) @keyword.control.import + (expr (primary (symbol) @namespace))? + (expr (primary (arrayConstr (exprColonExprList (exprColonExpr (expr (primary (symbol) @namespace)))))))?) +(fromStmt + (keyw) @keyword.control.import + (expr (primary (symbol) @namespace))? + (expr (primary (arrayConstr (exprColonExprList (exprColonExpr (expr (primary (symbol) @namespace)))))))?) +(includeStmt + (keyw) @keyword.control.import + (expr (primary (symbol) @namespace))? + (expr (primary (arrayConstr (exprColonExprList (exprColonExpr (expr (primary (symbol) @namespace)))))))?) +(importExceptStmt + (keyw) @keyword.control.import + (expr (primary (symbol) @namespace))? + (expr (primary (arrayConstr (exprColonExprList (exprColonExpr (expr (primary (symbol) @namespace)))))))?) +; import statements +; yeah, this is a bit gross. + ;; Control Flow -[ - "if" - "when" - "case" - "elif" - "else" -] @keyword.control.conditional -(of_branch "of" @keyword.control.conditional) +(ifStmt (keyw) @keyword.control.conditional) +(whenStmt (keyw) @keyword.control.conditional) +(elifStmt (keyw) @keyword.control.conditional) +(elseStmt (keyw) @keyword.control.conditional) +(caseStmt (keyw) @keyword.control.conditional) +(ofBranch (keyw) @keyword.control.conditional) +(inlineIfStmt (keyw) @keyword.control.conditional) +(inlineWhenStmt (keyw) @keyword.control.conditional) ; conditional statements ; todo: do block -"block" @keyword.control -(block label: (_) @label) +(forStmt + . (keyw) @keyword.control.repeat + . (symbol) @variable + . (keyw) @keyword.control.repeat) +(whileStmt (keyw) @keyword.control.repeat) +; loop statements + +(returnStmt (keyw) @keyword.control.repeat) +(yieldStmt (keyw) @keyword.control.repeat) +(discardStmt (keyw) @keyword.control.repeat) +(breakStmt (keyw) @keyword.control.repeat) +(continueStmt (keyw) @keyword.control.repeat) +; control flow statements + +(raiseStmt (keyw) @keyword.control.exception) +(tryStmt (keyw) @keyword.control.exception) +(tryExceptStmt (keyw) @keyword.control.exception) +(tryFinallyStmt (keyw) @keyword.control.exception) +(inlineTryStmt (keyw) @keyword.control.exception) +; (inlineTryExceptStmt (keyw) @keyword.control.exception) +; (inlineTryFinallyStmt (keyw) @keyword.control.exception) +; exception handling statements -[ - "for" - "while" - "continue" - "break" -] @keyword.control.repeat -(for "in" @keyword.control.repeat) +(staticStmt (keyw) @keyword) +(deferStmt (keyw) @keyword) +(asmStmt (keyw) @keyword) +(bindStmt (keyw) @keyword) +(mixinStmt (keyw) @keyword) +; miscellaneous blocks -[ - "return" - "yield" -] @keyword.control.return -; return statements +(blockStmt + (keyw) @keyword.control + (symbol) @label) +; block statements -[ - "try" - "except" - "finally" - "raise" -] @keyword.control.exception -; exception handling statements - -[ - "asm" - "bind" - "mixin" - "defer" - "static" -] @keyword -; miscellaneous keywords ;; Types and Type Declarations -[ - "let" - "var" - "const" - "type" - "object" - "tuple" - "enum" - "concept" -] @keyword.storage.type - -(var_type "var" @keyword.storage.modifier) -(out_type "out" @keyword.storage.modifier) -(distinct_type "distinct" @keyword.storage.modifier) -(ref_type "ref" @keyword.storage.modifier) -(pointer_type "ptr" @keyword.storage.modifier) - -(var_parameter "var" @keyword.storage.modifier) -(type_parameter "type" @keyword.storage.modifier) -(static_parameter "static" @keyword.storage.modifier) -(ref_parameter "ref" @keyword.storage.modifier) -(pointer_parameter "ptr" @keyword.storage.modifier) -; (var_parameter (identifier) @variable.parameter) -; (type_parameter (identifier) @variable.parameter) -; (static_parameter (identifier) @variable.parameter) -; (ref_parameter (identifier) @variable.parameter) -; (pointer_parameter (identifier) @variable.parameter) -; todo: when are these used?? - -(type_section - (type_declaration - (type_symbol_declaration - name: (_) @type))) -; types in type declarations - -(enum_field_declaration - (symbol_declaration - name: (_) @type.enum.variant)) -; types as enum variants - -(variant_declaration - alternative: (of_branch - values: (expression_list (_) @type.enum.variant))) -; types as object variants - -(case - (of_branch - values: (expression_list (_) @constant))) -; case values are guaranteed to be constant - -(type_expression - [ - (identifier) @type - (bracket_expression - [ - (identifier) @type - (argument_list (identifier) @type)]) - (tuple_construction - [ - (identifier) @type - (bracket_expression - [ - (identifier) @type - (argument_list (identifier) @type)])])]) -; types in type expressions - -(call - function: (bracket_expression - right: (argument_list (identifier) @type))) -; types as generic parameters - -; (dot_generic_call -; generic_arguments: (_) @type) -; ??? - -(infix_expression - operator: - [ - "is" - "isnot" - ] - right: (_) @type) -; types in "is" comparisons - -(except_branch - values: (expression_list - [ - (identifier) @type - (infix_expression - left: (identifier) @type - operator: "as" - right: (_) @variable)])) -; types in exception branches +(typeDef + (keyw) @keyword.storage.type + (symbol) @type) +; names of new types type declarations + +(exprColonEqExpr + . (expr (primary (symbol) @variable)) + . (expr (primary (symbol) @type))) +; variables in inline tuple declarations + +(primarySuffix + (indexSuffix + (exprColonEqExprList + (exprColonEqExpr + (expr + (primary + (symbol) @type)))))) +; nested types in brackets, i.e. seq[string] + +(primaryTypeDef (symbol) @type) +; primary types of type declarations (NOT nested types) + +(primaryTypeDef (primaryPrefix (keyw) @type)) +; for consistency + +(primaryTypeDesc (symbol) @type) +; type annotations, on declarations or in objects + +(primaryTypeDesc (primaryPrefix (keyw) @type)) +; var types etc + +(genericParamList (genericParam (symbol) @type)) +; types in generic blocks + +(enumDecl (keyw) @keyword.storage.type) +(enumElement (symbol) @type.enum.variant) +; enum declarations and elements + +(tupleDecl (keyw) @keyword.storage.type) +; tuple declarations + +(objectDecl (keyw) @keyword.storage.type) +(objectPart (symbol) @variable.other.member) +; object declarations and fields + +(objectCase + (keyw) @keyword.control.conditional + (symbol) @variable.other.member) +(objectBranch (keyw) @keyword.control.conditional) +(objectElif (keyw) @keyword.control.conditional) +(objectElse (keyw) @keyword.control.conditional) +(objectWhen (keyw) @keyword.control.conditional) +; variant objects + +(conceptDecl (keyw) @keyword.storage.type) +(conceptParam (keyw) @type) +(conceptParam (symbol) @variable) +; concept declarations, parameters, and qualifiers on those parameters + +((expr + (primary (symbol)) + (operator) @operator + (primary (symbol) @type)) + (#match? @operator "is")) +((exprStmt + (primary (symbol)) + (operator) @operator + (primary (symbol) @type)) + (#match? @operator "is")) +; symbols likely to be types: "x is t" means t is either a type or a type variable + +; distinct? + ;; Functions -[ - "proc" - "func" - "method" - "converter" - "iterator" - "template" - "macro" -] @keyword.function - -(exported_symbol "*" @attribute) -(_ "=" @punctuation.delimiter [body: (_) value: (_)]) - -(proc_declaration name: (_) @function) -(func_declaration name: (_) @function) -(iterator_declaration name: (_) @function) -(converter_declaration name: (_) @function) -(method_declaration name: (_) @function.method) -(template_declaration name: (_) @function.macro) -(macro_declaration name: (_) @function.macro) -(symbol_declaration name: (_) @variable) - -(call - function: [ - (identifier) @function.call - (dot_expression - right: (identifier) @function.call) - (bracket_expression - left: [ - (identifier) @function.call - (dot_expression - right: (identifier) @function.call)])]) -(generalized_string - function: [ - (identifier) @function.call - (dot_expression - right: (identifier) @function.call) - (bracket_expression - left: [ - (identifier) @function.call - (dot_expression - right: (identifier) @function.call)])]) -(dot_generic_call function: (_) @function.call) +(routine + . (keyw) @keyword.function + . (symbol) @function) +; function declarations + +(routineExpr (keyw) @keyword.function) +; discarded function + +(routineExprTypeDesc (keyw) @keyword.function) +; function declarations as types + +(primary + . (symbol) @function.call + . (primarySuffix (functionCall))) +; regular function calls + +(primary + . (symbol) @function.call + . (primarySuffix (cmdCall))) +; function calls without parenthesis + +(primary + (primarySuffix (qualifiedSuffix (symbol) @function.call)) + . (primarySuffix (functionCall))) +; uniform function call syntax calls + +(primary + (primarySuffix (qualifiedSuffix (symbol) @function.call)) + . (primarySuffix (cmdCall))) +; just in case + +(primary + (symbol) @constructor + (primarySuffix (objectConstr))) +; object constructor + +; does not appear to be a way to distinguish these without verbatium matching +; [] @function.builtin +; [] @function.method +; [] @function.macro +; [] @function.special + ;; Variables -(parameter_declaration - (symbol_declaration_list - (symbol_declaration - name: (_) @variable.parameter))) -(argument_list - (equal_expression - left: (_) @variable.parameter)) -(concept_declaration - parameters: (parameter_list (identifier) @variable.parameter)) - -(field_declaration - (symbol_declaration_list - (symbol_declaration - name: (_) @variable.other.member))) -(call - (argument_list - (colon_expression - left: (_) @variable.other.member))) -(tuple_construction - (colon_expression - left: (_) @variable.other.member)) -(variant_declaration - (variant_discriminator_declaration - (symbol_declaration_list - (symbol_declaration - name: (_) @variable.other.member)))) - -;; Miscellaneous Matches +(paramList (paramColonEquals (symbol) @variable.parameter)) +; parameter identifiers -[ - "cast" - "discard" - "do" -] @keyword -; also: addr end interface using - -(blank_identifier) @variable.builtin -((identifier) @variable.builtin - (#eq? @variable.builtin "result")) - -(dot_expression - left: (identifier) @variable - right: (identifier) @variable.other.member) +(identColon (ident) @variable.other.member) +; named parts of tuples + +(symbolColonExpr (symbol) @variable) +; object constructor parameters + +(symbolEqExpr (symbol) @variable) +; named parameters + +(variable + (keyw) @keyword.storage.type + (declColonEquals (symbol) @variable)) +; let, var, const expressions + +((primary (symbol) @variable.builtin) + (#match? @variable.builtin "result")) +; `result` is an implicit builtin variable inside function scopes + +((primary (symbol) @type) + (#match? @type "^[A-Z]")) +; assume PascalCase identifiers to be types + +((primary + (primarySuffix + (qualifiedSuffix + (symbol) @type))) + (#match? @type "^[A-Z]")) +; assume PascalCase member variables to be enum entries + +(primary (symbol) @variable) +; overzealous, matches variables + +(primary (primarySuffix (qualifiedSuffix (symbol) @variable.other.member))) +; overzealous, matches member variables: i.e. x in foo.x + +(keyw) @keyword +; more specific matches are done above whenever possible |