3 files changed, 388 insertions, 0 deletions
diff --git a/runtime/queries/nim/highlights.scm b/runtime/queries/nim/highlights.scm
new file mode 100644
index 00000000..1d325685
--- /dev/null
+++ b/runtime/queries/nim/highlights.scm
@@ -0,0 +1,315 @@
+;; Constants, Comments, and Literals
+
+(comment) @comment.line
+(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
+; note: somewhat irritatingly for testing, lits have the same syntax highlighting as types
+
+[
+  (str_lit)
+  (triplestr_lit)
+  (rstr_lit)
+  (generalized_str_lit)
+  (generalized_triplestr_lit)
+  (interpolated_str_lit)
+  (interpolated_triplestr_lit)
+] @string
+; [] @string.regexp
+; string literals
+
+[
+  "."
+  ","
+  ";"
+  ":"
+] @punctuation.delimiter
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+  "{."
+  ".}"
+  "#["
+  "]#"
+] @punctuation.bracket
+(interpolated_str_lit "&" @punctuation.special)
+(interpolated_str_lit "{" @punctuation.special)
+(interpolated_str_lit "}" @punctuation.special)
+; punctuation
+
+[
+  "and"
+  "or"
+  "xor"
+  "not"
+  "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)
+
+(pragma) @attribute
+; pragmas
+
+
+;; Imports and Exports
+
+(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
+
+(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
+
+(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
+
+(staticStmt (keyw) @keyword)
+(deferStmt (keyw) @keyword)
+(asmStmt (keyw) @keyword)
+(bindStmt (keyw) @keyword)
+(mixinStmt (keyw) @keyword)
+; miscellaneous blocks
+
+(blockStmt
+  (keyw) @keyword.control
+  (symbol) @label)
+; block statements
+
+
+;; Types and Type Declarations
+
+(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
+
+(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
+
+(paramList (paramColonEquals (symbol) @variable.parameter))
+; parameter identifiers
+
+(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
diff --git a/runtime/queries/nim/indents.scm b/runtime/queries/nim/indents.scm
new file mode 100644
index 00000000..67743540
--- /dev/null
+++ b/runtime/queries/nim/indents.scm
@@ -0,0 +1,54 @@
+[
+  (typeDef)
+  (ifStmt)
+  (whenStmt)
+  (elifStmt)
+  (elseStmt)
+  (ofBranch) ; note: not caseStmt
+  (whileStmt)
+  (tryStmt)
+  (tryExceptStmt)
+  (tryFinallyStmt)
+  (forStmt)
+  (blockStmt)
+  (staticStmt)
+  (deferStmt)
+  (asmStmt)
+  ; exprStmt?
+] @indent
+;; increase the indentation level
+
+[
+  (ifStmt)
+  (whenStmt)
+  (elifStmt)
+  (elseStmt)
+  (ofBranch) ; note: not caseStmt
+  (whileStmt)
+  (tryStmt)
+  (tryExceptStmt)
+  (tryFinallyStmt)
+  (forStmt)
+  (blockStmt)
+  (staticStmt)
+  (deferStmt)
+  (asmStmt)
+  ; exprStmt?
+] @extend
+;; ???
+
+[
+  (returnStmt)
+  (raiseStmt)
+  (yieldStmt)
+  (breakStmt)
+  (continueStmt)
+] @extend.prevent-once
+;; end a level of indentation while staying indented
+
+[
+  ")" ; tuples
+  "]" ; arrays, seqs
+  "}" ; sets
+] @outdent
+;; end a level of indentation and unindent the line
diff --git a/runtime/queries/nim/textobjects.scm b/runtime/queries/nim/textobjects.scm
new file mode 100644
index 00000000..943aa7f0
--- /dev/null
+++ b/runtime/queries/nim/textobjects.scm
@@ -0,0 +1,19 @@
+(routine
+  (block) @function.inside) @function.around
+
+; @class.inside (types?)
+; @class.around
+
+; paramListSuffix is strange and i do not understand it
+(paramList
+  (paramColonEquals) @parameter.inside) @parameter.around
+
+(comment) @comment.inside
+(multilineComment) @comment.inside
+(docComment) @comment.inside
+(multilineDocComment) @comment.inside
+
+(comment)+ @comment.around
+(multilineComment) @comment.around
+(docComment)+ @comment.around
+(multilineDocComment) @comment.around